Cómo instalar GitLab con Docker en Ubuntu 22.04

Gitlab Server es una versión de código abierto del control de versiones Gitlab alojado en la nube. La ventaja de autoalojar tus repositorios frente al alojamiento en la nube es el control total sobre tu código.

Esta guía te enseñará a instalar Gitlab Server utilizando Docker en un servidor Ubuntu 22.04. El servidor Gitlab ofrece dos ediciones: la edición gratuita Community y la edición de pago Enterprise. Nosotros instalaremos la edición Comunidad. Si quieres más funciones, puedes actualizarla fácilmente a la edición Enterprise.

Requisitos previos

• Un servidor con Ubuntu 22.04.
• Un usuario no root con privilegios sudo.
• Firewall sin complicaciones (UFW) activado y en ejecución.
• Un nombre de dominio totalmente cualificado (FQDN) que apunte al servidor como, por ejemplo, gitlab.example.com.
• Todo está actualizado.

  $ sudo apt update && sudo apt upgrade
  

Paso 1 – Configurar el Cortafuegos

El primer paso antes de instalar ningún paquete es configurar el cortafuegos para que permita las conexiones HTTP y HTTPS.

Comprueba el estado del cortafuegos.

$ sudo ufw status

Deberías ver algo como lo siguiente

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Permitir puertos HTTP y HTTPs.

$ sudo ufw allow http
$ sudo ufw allow https

Abre el puerto 587 para recibir correos a través de SMTP. Puede que estés utilizando un puerto diferente con tu servidor de correo SMTP.

$ sudo ufw allow http
$ sudo ufw allow 587

Comprueba de nuevo el estado para confirmarlo.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
587                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)
587 (v6)                   ALLOW       Anywhere (v6)

Paso 2 – Instalar dependencias

Antes de instalar Gitlab, necesitamos instalar ciertos paquetes que serán necesarios durante el transcurso de nuestro tutorial.

$ sudo apt install ca-certificates curl openssh-server apt-transport-https gnupg lsb-release -y

Algunos de estos paquetes pueden estar preinstalados en tu sistema.

Paso 3 – Cambiar el puerto SSH del sistema

Gitlab utiliza el puerto SSH por defecto, que entrará en conflicto con el puerto SSH del sistema. Para obtener mejores resultados, es mejor cambiar el puerto por defecto del sistema.

Para ello, abre el archivo /etc/ssh/sshd_config para editarlo.

$ sudo nano /etc/ssh/sshd_config

Busca la siguiente línea, elimina la almohadilla (#) que hay delante y cambia el valor de 22 por cualquier otro de tu elección. Para nuestro tutorial, hemos elegido 2425 cambiando

#Port 22

por

 Port 2425

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Reinicia el servicio SSH.

$ sudo systemctl restart sshd

Abre el puerto 2425 en el cortafuegos.

$ sudo ufw allow 2425

Cierra tu sesión SSH actual y vuelve a iniciar sesión utilizando el nuevo puerto.

$ ssh username@<serverIP> -p 2425

Paso 4 – Instala Docker y Docker Compose

Añade la clave GPG oficial de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Ejecuta el siguiente comando para añadir el repositorio de Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiza el sistema para incluir el repositorio de Docker.

$ sudo apt update

Instala Docker.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Este tutorial utilizará el plugin Docker Compose v2 en lugar del antiguo binario heredado. Por lo tanto, el comando para ejecutarlo ha cambiado de docker-compose a docker compose y esto se refleja aquí.

Docker se ejecuta con privilegios elevados, por lo que tendrás que utilizar sudo con frecuencia para ejecutar comandos. La mejor opción es añadir tu cuenta de usuario Linux al grupo de usuarios docker.

$ sudo usermod -aG docker ${USER}

La variable ${USER} recoge la cuenta del sistema actualmente conectada. Si no has iniciado sesión con el usuario al que quieres dar privilegios, sustituye ${USER} por el nombre de usuario.

Para solicitar la pertenencia al nuevo grupo, sal del servidor y vuelve a entrar, o utiliza el siguiente comando. Se te pedirá la contraseña del usuario.

$ su - $(USER)

Paso 5 – Configurar Volúmenes Docker

Antes de continuar con la instalación, necesitamos establecer la ubicación de los datos y la configuración de Gitlab a los que se accederá mediante volúmenes Docker.

Crea el directorio del volumen Docker.

$ sudo mkdir /srv/gitlab -p

Crea un directorio para el archivo Docker compose.

$ mkdir ~/gitlab-docker

Cambia al directorio.

$ cd ~/gitlab-docker

Crea un archivo de variables de entorno y ábrelo para editarlo.

$ nano .env

Pega el siguiente código para definir la variable $GITLAB_HOME.

GITLAB_HOME=/srv/gitlab

El contenedor Gitlab utiliza volúmenes montados en el host para almacenar datos persistentes. La siguiente tabla muestra la asignación de la ubicación local de los directorios de Gitlab a la ubicación de los contenedores y su uso respectivo.

Paso 6 – Instalar Gitlab usando Docker Compose

Asegúrate de que estás dentro del directorio Docker compose de Gitlab.

Crea y abre el archivo de configuración de Docker compose para editarlo.

$ nano docker-compose.yml

Pega el siguiente código en él.

version: '3.6'
services:
  web:
    image: 'gitlab/gitlab-ee:latest'
    container_name: 'gitlab-howtoforge'
    restart: always
    hostname: 'gitlab.example.com'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'https://gitlab.example.com'
        gitlab_rails['smtp_enable'] = true
        gitlab_rails['smtp_address'] = "email-smtp.us-west-2.amazonaws.com"
        gitlab_rails['smtp_user_name'] = "SESUsername"
        gitlab_rails['smtp_password'] = "SESKey"
        gitlab_rails['smtp_domain'] = "example.com"
        gitlab_rails['smtp_enable_starttls_auto'] = true
        gitlab_rails['smtp_port'] = 587
        gitlab_rails['smtp_authentication'] = "login"
        gitlab_rails['gitlab_email_from'] = '[email protected]'
        gitlab_rails['gitlab_email_reply_to'] = '[email protected]'
        # Add any other gitlab.rb configuration here, each on its own line
    ports:
      - '80:80'
      - '443:443'
      - '22:22'
      - '587:587'
    volumes:
      - '$GITLAB_HOME/config:/etc/gitlab'
      - '$GITLAB_HOME/logs:/var/log/gitlab'
      - '$GITLAB_HOME/data:/var/opt/gitlab'
    shm_size: '256m'

Echemos un vistazo a todas las opciones definidas en el archivo.

• image se refiere a la ubicación de la imagen Docker de Gitlab en Dockerhub.
• nombre_contenedor te permite aplicar una etiqueta a tu contenedor Docker, para utilizarla cuando hagas referencia al contenedor dentro de una red Docker.
• reiniciar especifica una política de reinicio para el contenedor. Establecerla como siempre significa que, si se sale del contenedor, éste se reiniciará automáticamente.
• hostname define el nombre de host interno del contenedor o, en este caso, la URL donde se instalará tu Gitlab.
• environment proporciona la variable GITLAB_OMNIBUS_CONFIG que te permite introducir cualquier ajuste de configuración de Gitlab.
• external_url se refiere al dominio donde se instalará tu Gitlab. El uso del protocolo https garantiza la instalación automática del certificado SSL Let’s Encrypt.
• Detalles SM TP – hemos incluido detalles SMTP para que la instancia de Gitlab pueda enviar correos electrónicos y notificaciones importantes. Para nuestro tutorial, estamos utilizando el servicio SES de Amazon. Sin embargo, puedes utilizar cualquier servicio de tu elección. Consulta la documentación de Gitlab sobre los servicios de correo SM TP para saber cómo configurarlos.
• ports indican al contenedor que publique puertos o un rango de puertos en el host. Como Gitlab necesita los puertos 22(SSH), 80(HTTP), 443(HTTPS) y 587(SMTP), se han expuesto al sistema. Si quieres que Gitlab utilice un puerto no estándar en tu servidor (probablemente porque no está disponible), primero proporcionarías el puerto del host y luego el puerto del contenedor. Por ejemplo, como tu servidor ya está utilizando el puerto SSH(22), puedes decirle a Gitlab que utilice SSH a través de un puerto diferente, digamos 3333. Entonces cambiarías 22:22 en el archivo anterior por 3333:22. También tendrás que añadir la línea gitlab_rails['gitlab_shell_ssh_port'] = 3333 en GITLAB_OMNIBUS_CONFIG más arriba.
• Elvolumen define los directorios presentes en el servidor para almacenar datos persistentes. Como se definió en el paso 5, ahora se puede utilizar $GITLAB_HOME en el archivo de composición para montar los directorios pertinentes en el contenedor.
• shm_size se refiere a la memoria compartida utilizada por el contenedor. Por defecto, Docker asigna 64MB al directorio de memoria compartida (montado en /dev/shm). Esto puede resultar insuficiente para las métricas Prometheus que genera el contenedor Gitlab. Por tanto, un mínimo de 256MB de memoria compartida garantiza el buen funcionamiento de Docker. Puedes aumentar su valor en función de la RAM que tenga tu sistema. Alternativamente, puedes desactivar las métricas de Prometheus desde el área de administración tras la instalación. Exploraremos esto en el siguiente paso.

Inicia el contenedor Docker de Gitlab.

$ docker compose up -d

El proceso tardará unos minutos en finalizar. Puedes seguir el progreso utilizando los registros de Docker.

$ docker logs gitlab-howtoforge -f

Pulsa Ctrl + C para salir de la monitorización del registro.

Puedes comprobar el estado del contenedor Gitlab utilizando el siguiente comando.

$ docker ps

A partir de Gitlab 14.0, se genera automáticamente una contraseña de root y se almacena en el archivo initiall_root_password. Este archivo se encuentra en el directorio /srv/gitlab/config. Ejecuta el siguiente comando para ver la contraseña raíz.

$ sudo cat /srv/gitlab/config/initial_root_password

Recibirás una salida similar.

# WARNING: This value is valid only in the following conditions
#          1. If provided manually (either via `GITLAB_ROOT_PASSWORD` environment variable or via `gitlab_rails['initial_root_password']` setting in `gitlab.rb`, it was provided before database was seeded for the first time (usually, the first reconfigure run).
#          2. Password hasn't been changed manually, either via UI or via command line.
#
#          If the password shown here doesn't work, you must reset the admin password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.

Password: Hz3t7Etn18wB6VAfBWyDlYbN2VQdMCO0xIIENfDHcFo=

# NOTE: This file will be automatically deleted in the first reconfigure run after 24 hours.

Copia la contraseña y guárdala para utilizarla más adelante. Ahora que todo está configurado, podemos proceder con la configuración.

Paso 7 – Configurar Gitlab

Acceder a Gitlab

Abre la URL https://gitlab.example.com en tu navegador y obtendrás la siguiente pantalla de acceso.

Introduce root como nombre de usuario y la contraseña que has obtenido en el paso anterior para acceder a tu panel de control de Gitlab. Al iniciar sesión, accederás a la siguiente pantalla del panel de control.

Como puedes ver, Gitlab ya ha creado un proyecto para monitorizar la instancia.

Restringir las inscripciones públicas

Por defecto, cualquiera puede crear una cuenta y obtener acceso. Si no lo deseas, puedes desactivarlo. Afortunadamente, la configuración para ello se muestra en forma de pantalla emergente en el panel de control. Haz clic en el botón Desactivar para restringir los registros públicos en tu instancia de Gitlab. Al hacerlo, se te redirigirá a la siguiente página de configuración.

Desmarca la opción Registro habilitado para restringirlos. Pulsa el botón Guardar cambios para aplicar la configuración.

En caso de que no veas la ventana emergente en tu panel de control, puedes acceder a la página de configuración pulsando el botón Menú y accediendo desde allí al panel de administración.

Una vez dentro del panel de administración, pasa el ratón por encima de la opción Configuración de la barra lateral izquierda y haz clic en el submenú General. Desde ahí puedes acceder al panel de restricciones de registro.

Configurar el perfil de Gitlab

Tu perfil por defecto es bastante soso y no tiene nada que mostrar. Para cambiarlo, haz clic en el icono de usuario de la esquina superior izquierda para que aparezca el menú desplegable y selecciona la opción Editar perfil.

Accederás a la página Configuración del perfil, donde podrás añadir tu nombre, correo electrónico y otra información sobre ti. Haz clic en Actualizar configuración del perfil cuando hayas terminado. No vuelvas a la página principal, ya que tenemos algunas cosas más que configurar aquí.

Cambiar la contraseña raíz

Este es uno de los pasos más importantes. Debes cambiar tu contraseña raíz por defecto inmediatamente. En versiones anteriores, Gitlab te obligaba a cambiarla como parte de la instalación, pero ahora lo ha hecho opcional. Para cambiar tu contraseña, haz clic en el menú Contraseña de la barra lateral izquierda.

Introduce los datos de tu contraseña y haz clic en Guardar contraseña para realizar el cambio. Saldrás de tu instancia y tendrás que volver a iniciar sesión.

Cambiar el nombre de usuario

Puedes cambiar tu nombre de usuario predeterminado de Gitlab de root a cualquier otro de tu elección. Para ello, haz clic en el menú Cuenta de la barra lateral izquierda.

Una vez en la página, introduce tu nuevo nombre de usuario y haz clic en el botón Actualizar nombre de usuario para realizar el cambio. Se te volverá a pedir confirmación. Pulsa de nuevo el botón Actualizar nombre de usuario para confirmar el cambio.

También deberías activar aquí la autenticación de dos factores para mejorar la seguridad de tu cuenta.

Desactiva las Métricas de Prometheus y mejora la Privacidad

En el paso anterior, hablamos de aumentar el tamaño de la memoria compartida para el droplet y de mantenerla en un mínimo de 256 MB. Se necesita principalmente para almacenar en el disco los datos relacionados con las métricas de Prometheus. Si no la utilizas, debes desactivarla. Sólo puedes hacerlo después de la instalación. Para desactivarla, abre el Panel de Administración desde la barra de menús.

Una vez dentro del Panel de Administración, abre la opción de menú Configuración >> Métricas y perfiles.

En la página Métricas, despliega la sección Métricas – Prometheus y desmarca la opción Habilitar punto final de métricas de salud y rendimiento. Haz clic en el botón Guardar cambios para aplicar el cambio.

Gitlab también recopila información de uso de cada instalación. Si valoras la privacidad y no quieres que ocurra, despliega la opción Estadísticas de uso en la misma página y desmarca la opción Activar Ping de servicio. Haz clic en el botón Guardar cambios para aplicar el cambio.

Paso 8 – Crear tu primer Proyecto

Intentemos crear nuestro primer proyecto y enviar un commit.

Añadir tu clave SSH

Antes de seguir adelante, debemos añadir nuestra clave SSH. Esto nos permite interactuar con nuestra instalación sin utilizar contraseñas. Si tienes una clave SSH, puedes saltarte el siguiente comando. Si no la tienes, puedes crear una utilizando el siguiente comando.

$ ssh-keygen -t ed25519 -C "gitlab.example.com"

Este comando es común a macOS, Linux y Git Bash/WSL en Windows. Acepta los valores predeterminados e introduce una frase de contraseña segura. Vamos a crear las claves SSH en el Terminal Powershell de Windows.

Generating public/private rsa key pair.
Generating public/private ed25519 key pair.
Enter file in which to save the key (C:\Users\<username>/.ssh/id_ed25519):
Enter same passphrase again:
Your identification has been saved in C:\Users\<username>/.ssh/id_ed25519.
Your public key has been saved in C:\Users\<username>/.ssh/id_ed25519.pub.
SHA256:CI3Ja1LSTN+j4LQnDYkAoP+DvZB8SWrD26zDyUBRbUY gitlab.example.com
+--[ED25519 256]--+
|* ..+E           |
|. + / o o        |
| o = B o .       |
|. o B = S        |
|.o X +           |
| +X.*            |
| .=B o           |
+----[SHA256]-----+

Añade la identidad de la clave privada al agente de autenticación SSH. Asegúrate de que se está ejecutando el servicio Agente de autenticación OpenSSH si estás en Windows. Si estás en Linux o macOS, ejecuta el siguiente comando.

$ eval $(ssh-agent -s)

Añade la clave.

$ ssh-add C:\Users\<username>/.ssh/id_ed25519

En Linux y macOS, el comando cambiará a

$ ssh-add ~/.ssh/id_ed25519

Se te pedirá la frase de contraseña. Introdúcela y se añadirá la clave.

A continuación, tenemos que guardar esta configuración en el archivo ~/.ssh/config. En Windows, será el directorio C:\Users\<username>\.ssh. Pega el siguiente código al final del archivo.

Host gitlab.example.com
  PreferredAuthentications publickey
  IdentityFile ~/.ssh/id_ed25519

En este archivo, el nombre de la ruta seguirá siendo el mismo en todos los sistemas operativos. Guarda el archivo.

A continuación, tenemos que copiar la clave pública en nuestra cuenta de Gitlab. Puedes mostrar tu clave pública mediante el siguiente comando. De nuevo, el nombre de la ruta funcionará en todos los sistemas operativos.

$ cat ~/.ssh/id_ed25519.pub

Obtendrás un resultado similar.

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAml2KPhmGkdMWv7jksLKO13u3g1zI9CumKDQSpv7lYh gitlab.example.com

Abre la configuración de tu perfil en Gitlab y selecciona el menú Claves SS H de la barra lateral izquierda.

Pega la clave SSH en la casilla correspondiente y haz clic en Añadir Clave para continuar.

A continuación, tenemos que comprobar si nuestra conexión SSH funciona correctamente. Ejecuta el siguiente comando en el terminal de tu PC.

$ ssh -T [email protected]

Obtendrás una salida similar. En primer lugar, se te pedirá que añadas la clave SSH a la lista de hosts conocidos de tu sistema. Escribe «Sí» para continuar. También recibirás un aviso de que la clave SSH de la instancia de Gitlab y la IP de tu servidor no coinciden y se te volverá a preguntar si quieres continuar. Vuelve a escribir sí. Finalmente, recibirás un mensaje de éxito confirmando la conexión a tu instancia de Gitlab.

The authenticity of host 'gitlab.example.com (192.0.2.0)' can't be established.
ECDSA key fingerprint is SHA256:g5mOqAY2A3lhXW0flnLGdSU7RrDnbRFKVJCquAhLXqk.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'gitlab.example.com' (ECDSA) to the list of known hosts.
Warning: the ECDSA host key for 'gitlab.example.com' differs from the key for the IP address '192.0.2.0'
Are you sure you want to continue connecting (yes/no)? yes
Offending key for IP in C:\Users\navjo/.ssh/known_hosts:7
Welcome to GitLab, @navjot!

Ahora, podemos pasar a crear nuestro primer repositorio y hacer algunos commits.

Crear un proyecto

Cada repositorio en Gitlab pertenece a un proyecto. Un proyecto incluye un repositorio, un gestor de incidencias, solicitudes de fusión, una wiki, canalizaciones de integración continua y entrega continua (CI/CD), y muchas otras características.

Para crear tu primer repositorio, haz clic en el botón Nuevo proyecto de tu página de inicio.

Accederás a la página Nuevo proyecto, donde se te darán varias opciones sobre cómo crear un nuevo proyecto.

Selecciona la opción Crear proyecto en blanco para continuar. En la página siguiente, introduce el nombre del proyecto. Selecciona tu nombre de usuario en el menú desplegable de la opción URL del proyecto. Establece el slug de tu proyecto. Introduce una descripción del proyecto si quieres y cambia la visibilidad del proyecto según tus necesidades. Puedes Inicializar tu repositorio con un archivo README.

Cuando hayas terminado, haz clic en Crear proyecto. Accederás a la página de tu repositorio con un único archivo README.md en blanco.

Ahora que nuestro repositorio está activo, intentemos añadir un registro de cambios desde la línea de comandos. Introduce los siguientes comandos en tu ordenador para crear un archivo CHANGELOG y enviarlo a tu repositorio. Asegúrate de que tienes Git instalado en tu ordenador.

El primer paso es clonar el repositorio. Puedes clonar utilizando SSH o HTTPS. Clona utilizando SSH. Se te pedirá la contraseña.

$ git clone [email protected]:user/howtoforge-test.git

Introduce el resto de los comandos para crear y enviar el archivo CHANGELOG.

$ cd howtoforge-test
$ touch CHANGELOG  # Or create the file in your editor and enter a project description
$ git add CHANGELOG
$ git commit -m "add Changelog"
$ git push -u origin main

Se te pedirá de nuevo la contraseña durante el comando push.

Vuelve a la página de tu proyecto Gitlab y verás el archivo CHANGELOG en ella. ¡Enhorabuena! Has creado con éxito tu primer proyecto y le has enviado un archivo.

Paso 9 – Gestionar el Contenedor Gitlab

Veamos cómo puedes gestionar el contenedor Gitlab utilizando comandos sencillos.

Si en algún momento quieres detener el contenedor, emite el siguiente comando desde dentro del directorio Docker compose.

$ docker compose down

Para iniciarlo de nuevo, emite el siguiente comando.

$ docker compose up -d

Si quieres cambiar alguna configuración o añadir otra a tu instancia de Gitlab, puedes hacerlo editando el archivo docker-compose.yml en la variable GITLAB_OMNIBUS_CONFIG. Una vez que hayas realizado el cambio, tendrás que reiniciar el contenedor para aplicar el cambio. Ejecuta los siguientes comandos para actualizar el contenedor con la nueva configuración.

$ docker compose down --remove-orphans
$ docker compose up -d

Para reiniciar el contenedor, emite el siguiente comando. Sin embargo, el siguiente comando de reinicio no recoge los cambios realizados en el archivo Docker compose.

$ docker compose restart

Accede al shell del contenedor.

$ docker exec -it <container name> bash

Paso 10 – Haz una copia de seguridad de Gitlab

Se puede hacer una copia de seguridad de Gitlab mediante un único comando.

$ docker exec -t gitlab-howtoforge gitlab-backup create

El archivo de copia de seguridad se guarda en el directorio /srv/gitlab/data/backups. Esta copia de seguridad no contiene tu archivo de configuración gitlab-secrets.json. Este archivo se encuentra en el directorio /srv/gitlab/config. Por lo tanto, tienes que hacer una copia de seguridad de este archivo por separado. Existe otro archivo de configuración, gitlab.rb, que contiene toda la configuración de la instancia de Gitlab. Pero en nuestro caso, hemos utilizado la variable GITLAB_OMNIBUS_CONFIG en nuestro archivo de composición, por lo que este archivo no es utilizado por Gitlab. Para hacer cualquier cambio en Gitlab, tendrás que definirlo a través de la variable. Por lo tanto, también tendrás que hacer una copia de seguridad del archivo de composición.

Puedes crear una entrada cron para hacer copias de seguridad de tu instalación de Gitlab regularmente.

Paso 11 – Restaurar Gitlab

Para restaurar Gitlab, deberás tener una instalación de Gitlab que funcione en otro sistema. También tendrás que copiar tu directorio de configuración y sobrescribir la configuración de la instalación existente.

Restaurar Gitlab requiere ejecutar varios comandos. En primer lugar, tienes que detener los procesos conectados a la base de datos.

$ docker exec -it <name of container> gitlab-ctl stop puma
$ docker exec -it <name of container> gitlab-ctl stop sidekiq

Sustituye <name of container> por el nombre del contenedor en tu nuevo servidor.

Comprueba que los procesos están parados antes de continuar.

$ docker exec -it <name of container> gitlab-ctl status

Copia el archivo de copia de seguridad en el directorio /srv/gitlab/data/backups. Crea el directorio si no existe.

Ejecuta el comando restaurar. Debes eliminar del comando la parte _gitlab_backup.tar del nombre del archivo.

$ docker exec -it <name of container> gitlab-backup restore BACKUP=11493107454_2018_04_25_10.6.4-ce

Copia el archivo gitlab-secrets.json y sobrescribe la copia existente en el directorio /srv/gitlab/config del nuevo servidor. Además, copia toda la configuración de Gitlab del archivo de composición del que se ha hecho copia de seguridad al archivo del nuevo contenedor.

Reinicia el contenedor de Gitlab. No podemos utilizar directamente el comando docker compose restart, ya que no recogerá los cambios realizados en el archivo de composición que necesitamos.

$ docker compose down --remove-orphans
$ docker compose up -d

Comprueba Gitlab.

$ docker exec -it <name of container> gitlab-rake gitlab:check SANITIZE=true

Paso 12 – Actualizar Gitlab

Para actualizar Gitlab, el primer paso es hacer una copia de seguridad como se muestra en la parada anterior.

A continuación, cambia al directorio Docker compose de Gitlab.

$ cd ~/gitlab-docker

A continuación, detén y elimina el contenedor existente. No obstante, tus datos se conservarán.

$ docker compose down --remove-orphans

Saca la última versión de la imagen Docker de Gitlab.

$ docker compose pull

Inicia de nuevo los contenedores.

$ docker compose up -d

Este proceso está bien para actualizar entre versiones menores de Gitlab, pero cuando actualices a una versión mayor, tendrás que seguir pasos adicionales y tomar precauciones. Deberías consultar la documentación de Gitlab antes de realizar la actualización.

Conclusión

Con esto concluye nuestro tutorial en el que has aprendido a instalar Gitlab utilizando Docker en un servidor Ubuntu 22.04. También has creado tu primer proyecto y le has enviado un archivo desde tu PC. Si tienes alguna pregunta, publícala en los comentarios a continuación.