Guía completa para la gestión de repositorios con GitLab

Instalación y Configuración de GitLab

GitLab es una plataforma de gestión de código fuente y colaboración de desarrolladores. A continuación, se detallan los métodos de instalación y configuración.

Instalación mediante Docker

Docker simplifica el despliegue de GitLab. Se recomienda configurar una variable de entorno $GITLAB_HOME para persistir datos, configuraciones y logs.

Configuración de Directorios (Linux/macOS):

  • Linux: export GITLAB_HOME=/srv/gitlab
  • macOS: export GITLAB_HOME=$HOME/gitlab

Los volúmenes de Docker mapean los datos persistentes:

  • $GITLAB_HOME/data: Almacena datos de la aplicación (/var/opt/gitlab en el contenedor).
  • $GITLAB_HOME/logs: Guarda los archivos de log (/var/log/gitlab en el contenedor).
  • $GITLAB_HOME/config: Contiene la configuración de GitLab (/etc/gitlab en el contenedor).

Ejecución con Docker Engine

Para iniciar GitLab con Docker Engine, utilice el siguiente comando. Ajuste los puertos y el nombre del host según sea necesario. El parámetro --restart always asegura que el contenedor se reinicie automáticamente.

sudo docker run --detach \
 --hostname gitlab.example.com \
 --publish 443:443 --publish 80:80 --publish 23:22 \
 --name gitlab \
 --restart always \
 --volume $GITLAB_HOME/config:/etc/gitlab \
 --volume $GITLAB_HOME/logs:/var/log/gitlab \
 --volume $GITLAB_HOME/data:/var/opt/gitlab \
 --shm-size 256m \
 registry.gitlab.cn/omnibus/gitlab-jh:latest

Para entornos con SELinux, añada el sufijo :Z a los volúmenes:

sudo docker run --detach \
 --hostname gitlab.example.com \
 --publish 443:443 --publish 80:80 --publish 22:22 \
 --name gitlab \
 --restart always \
 --volume $GITLAB_HOME/config:/etc/gitlab:Z \
 --volume $GITLAB_HOME/logs:/var/log/gitlab:Z \
 --volume $GITLAB_HOME/data:/var/opt/gitlab:Z \
 --shm-size 256m \
 registry.gitlab.cn/omnibus/gitlab-jh:latest

Si utiliza integración Kerberos, exponga también los puertos Kerberos necesarios (ej. --publish 8443:8443).

Puede monitorear el proceso de inicialización con:

sudo docker logs -f gitlab

Acceda a GitLab a través de su dominio o dirección IP. La contraseña inicial del usuario root se puede obtener con:

sudo docker exec -it gitlab grep 'Password:' /etc/gitlab/initial_root_password

Instalación con Docker Compose

Docker Compose ofrece una forma declarativa de definir y ejecutar aplicaciones multi-contenedor. Aquí se presenta un ejemplo de archivo docker-compose.yml:

version: '3.6'
services:
 web:
   image: 'registry.gitlab.cn/omnibus/gitlab-jh:latest'
   restart: always
   hostname: 'gitlab.example.com'
   environment:
     GITLAB_OMNIBUS_CONFIG: |
       external_url 'https://gitlab.example.com'
       # Agregue aquí cualquier otra configuración de gitlab.rb
   ports:
     - '80:80'
     - '443:443'
     - '22:22'
   volumes:
     - '$GITLAB_HOME/config:/etc/gitlab'
     - '$GITLAB_HOME/logs:/var/log/gitlab'
     - '$GITLAB_HOME/data:/var/opt/gitlab'
   shm_size: '256m'

Para iniciar GitLab, ejecute:

docker compose up -d

Si necesita configurar puertos HTTP y SSH personalizados, ajuste la sección ports y la variable GITLAB_OMNIBUS_CONFIG en consecuencia:

version: '3.6'
services:
 web:
   image: 'registry.gitlab.cn/omnibus/gitlab-jh:latest'
   restart: always
   hostname: 'gitlab.example.com'
   environment:
     GITLAB_OMNIBUS_CONFIG: |
       external_url 'http://gitlab.example.com:8929'
       gitlab_rails['gitlab_shell_ssh_port'] = 2224
   ports:
     - '8929:8929'
     - '2224:22'
   volumes:
     - '$GITLAB_HOME/config:/etc/gitlab'
     - '$GITLAB_HOME/logs:/var/log/gitlab'
     - '$GITLAB_HOME/data:/var/opt/gitlab'
   shm_size: '256m'

Instalación en Linux (CentOS)

Para instalar GitLab CE en CentOS, primero instale las dependencias necesarias y luego el paquete RPM.

# Instalar dependencias
yum install policycoreutils-python

# Instalar GitLab CE
rpm -i gitlab-ce-16.7.0-ce.0.el7.x86_64.rpm

Después de la instalación, modifique el archivo de configuración /etc/gitlab/gitlab.rb para establecer la URL externa:

# Modificar configuración
vim /etc/gitlab/gitlab.rb
external_url 'http://<ip_o_dominio>:<puerto>'</puerto></ip_o_dominio>

Aplique la configuración y reinicie GitLab:

# Recargar configuración
gitlab-ctl reconfigure
# Reiniciar servicio
gitlab-ctl restart

La contraseña inicial de root se encuentra en:

cat /etc/gitlab/initial_root_password

Gestión Básica de Git

Esta sección cubre operaciones fundamentales de Git, incluyendo la configuración del usuario, la creación de repositorios, y el manejo de commits y ramas.

Configuración del Usuario en Git

Establezca su nombre de usuario y correo electrónico globalmente o por repositorio.

git config user.name "Tu Nombre"
git config user.email "tu.correo@ejemplo.com"

# Verificar configuración
git config user.name
git config user.email

Creación y Clonación de Repositorios

Puede crear nuevos repositorios o clonar existentes desde una URL remota.

# Clonar un repositorio usando HTTP
git clone http://<url_gitlab>/usuario/repo.git</url_gitlab>

Se le solicitará el nombre de usuario y contraseña de GitLab.

Ciclo de Vida de los Cambios: Add, Commmit, Push

Comprender el flujo de trabajo de Git es crucial.

  • Área de trabajo (Working Directory): Los archivos que usted edita.
  • Área de preparación (Staging Area/Index): Donde agrupa los cambios para el próximo commit.
  • Repositorio (Repository): Donde se almacena el historial de versiones.

Añadir Cambios al Staging Area

Use git add para seleccionar los archivos modificados que desea incluir en el próximo commit.

# Añadir un archivo específico
git add nombre_archivo.java

# Añadir todos los cambios en el directorio actual
git add .

# Añadir cambios de forma interactiva
git add -p

Los archivos añadidos al staging area se muestran en verde.

Realizar un Commit

Guarde los cambios del staging area en el repositorio local con un mensaje descriptivo.

git commit -m "Mensaje descriptivo del commit"

Enviar Cambios al Repositorio Remoto

git push sube sus commits locales al repositorio remoto (ej. GitLab).

git push origin <nombre-rama></nombre-rama>

Manejo de Ramas (Branches)

Las ramas permiten desarrollar nuevas funcionalidades o corregir errores de forma aislada.

Creación y Cambio de Ramas

# Crear una nueva rama
git branch nombre_rama

# Crear y cambiar a una nueva rama
git checkout -b nueva_rama

# Cambiar a una rama existente
git checkout rama_existente
# O usando el comando más moderno:
git switch rama_existente

# Listar todas las ramas (locales y remotas)
git branch -a

Enviar una Rama al Remoto

Para que una rama local esté disponible en GitLab, debe ser enviada explícitamente.

# Enviar la rama y establecer el seguimiento remoto
git push --set-upstream origin nombre_rama_local

Fusión de Ramas (Merge)

Integre los cambios de una rama en otra.

# Cambiar a la rama destino (ej. main)
git checkout main

# Fusionar la rama origen (ej. feature-rama) en la rama actual
git merge feature-rama

Resolución de Conflictos

Los conflictos ocurren cuando Git no puede fusionar automáticamente cambios de diferentes ramas que modifican las mismas líneas de código.

Cuando ocurre un conflicto, GitLab marcará los archivos afectados. Deberá editar manualmente los archivos para resolver las diferencias, luego añadirlos al staging area y realizar un nuevo commit.

# Después de editar y resolver conflictos:
git add archivo_con_conflicto.java
git commit -m "Resuelto conflicto de fusión"

Alternativamente, puede usar git stash para guardar temporalmente los cambios locales antes de la fusión y luego recuperarlos con git stash pop.

Deshacer Cambios

Git ofrece varias formas de revertir operaciones.

Deshacer git add

Para retirar un archivo del staging area:

# Retirar un archivo del staging area
git reset nombre_archivo.java

Deshacer un commit

Existen dos enfoques principales:

  • git reset: Mueve el puntero de la rama. Use --soft para mantener los cambios en staging, --mixed (predeterminado) para mantenerlos en el directorio de trabajo, o --hard para descartarlos (¡peligroso!).
# Deshacer el último commit y mantener cambios en staging
git reset --soft HEAD^
  1. git revert: Crea un nuevo commit que deshace los cambios de un commit anterior. Es más seguro ya que no altera el historial.
# Revertir un commit específico (esto crea un nuevo commit de reversión)
git revert <hash_del_commit></hash_del_commit>

Si los cambios ya han sido enviados a GitLab, git revert es generalmente la opción preferida.

Revertir Código (Rollback)

Para retroceder a una versión anterior específica del código:

  • Usando git reset --hard: Descartará todos los cambios posteriores al commit especificado.
git reset --hard <hash_del_commit></hash_del_commit>
  1. Usando git revert: Creará un nuevo commit que deshace los cambios de commits posteriores.
git revert <hash_del_commit_a_deshacer></hash_del_commit_a_deshacer>

Archivo .gitignore

Especifique archivos o directorios que Git debe ignorar y no rastrear.

# Ignorar archivos compilados
*.class
*.jar

# Ignorar directorios de build/logs
target/
logs/

# Ignorar archivos de configuración de IDE
.idea/
*.iml

Copia de Seguridad y Restauración de Repositorios

GitLab proporciona herramientas para respaldar y restaurar sus repositorios.

Creación de Copia de Seguridad

Desde la línea de comandos del servidor GitLab:

sudo gitlab-rake gitlab:backup:create

Los backups se guardan por defecto en /var/opt/gitlab/backups.

Restauración de Copia de Seguridad

En el servidor de destino, utilice el siguiente comando, especificando el nombre del archivo de backup (sin la extensión):

gitlab-rake gitlab:backup:restore BACKUP=<nombre_archivo_backup></nombre_archivo_backup>

Nota: Asegúrese de que el servidor GitLab esté detenido antes de restaurar.

Etiquetas: GitLab Docker docker-compose Git control-de-versiones

Publicado el 7-21 10:55

Etiquetas populares

©2026 Friki Work