Comment installer GitLab CE avec Docker sur Debian 12

Gitlab Server est une version open source du contrôle de version Gitlab hébergé dans le cloud. L'avantage de l'auto-hébergement de vos référentiels par rapport à l'hébergement cloud est que vous obtenez un contrôle total sur votre code.

Ce guide vous montrera comment installer le serveur Gitlab à l'aide de Docker sur Debian 12. Le serveur Gitlab propose deux éditions : l'édition Community gratuite et l'édition Enterprise payante. Nous allons installer l'édition communautaire. Vous pouvez facilement le mettre à niveau vers l'édition Enterprise si vous souhaitez plus de fonctionnalités.

Ce guide a été rédigé à l'origine par Navjot Singh pour Ubuntu 22.04 et a été modifié et mis à jour pour Debian 12.

Conditions préalables

Un serveur exécutant Debian 12

Un nom de domaine complet (FQDN) pointant vers le serveur comme gitlab.example.com.

• Vous êtes connecté en tant qu'utilisateur root.
• Tout est mis à jour.

apt update && apt upgrade

Étape 1 - Installer les dépendances

Avant d'installer Gitlab, nous devons installer certains packages requis lors de notre tutoriel.

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

Certains de ces packages peuvent être préinstallés sur votre système.

Étape 2 - Changer le port SSH du système

Gitlab utilise le port SSH par défaut, qui entrera en conflit avec le port SSH du système. Il est préférable de modifier le port par défaut du système pour de meilleurs résultats.

Pour ce faire, ouvrez le fichier /etc/ssh/sshd_config pour le modifier.

nano /etc/ssh/sshd_config

Recherchez la ligne suivante, supprimez le hachage (#) devant elle et modifiez la valeur de 22 par toute autre valeur de votre choix. Pour notre tutoriel, nous avons choisi 2425 en changeant

#Port 22

à

 Port 2222

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Redémarrez le service SSH.

systemctl restart sshd

Fermez votre session SSH actuelle et reconnectez-vous en utilisant le nouveau port.

ssh username@<serverIP> -p 2222

Étape 3 - Installer Docker et Docker Compose

Ajoutez la clé GPG officielle de Docker.

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

Exécutez la commande suivante pour ajouter le référentiel Docker.

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

Mettez à jour le système pour inclure le référentiel Docker.

apt update

Installez Docker.

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

Ce didacticiel utilisera le plugin Docker Compose v2 au lieu de l'ancien binaire hérité. Par conséquent, la commande pour l'exécuter est passée de docker-compose à docker compose et cela se reflète ici.

Docker s'exécute avec des privilèges élevés, vous devrez donc utiliser fréquemment sudo pour exécuter des commandes. Il est préférable d'ajouter votre compte utilisateur Linux au groupe d'utilisateurs.

usermod -aG docker ${USER}

La variable $ {USER} récupère le compte système actuellement connecté. Si vous n'êtes pas connecté avec l'utilisateur auquel vous souhaitez accorder des privilèges, remplacez $ {USER} par le nom d'utilisateur.

Pour demander une nouvelle adhésion au groupe, déconnectez-vous du serveur et reconnectez-vous, ou utilisez la commande suivante. Vous serez invité à saisir le mot de passe de l'utilisateur.

su - $(USER)

Étape 4 - Configurer les volumes Docker

Avant l'installation, nous devons définir l'emplacement des données et de la configuration Gitlab accessibles via les volumes Docker.

Créez le répertoire de volumes Docker.

mkdir -p /opt/gitlab/vol

Basculez vers le répertoire /opt/gitlab.

cd /opt/gitlab 

Créez un fichier de variable d'environnement et ouvrez-le pour le modifier.

nano .env

Collez le code suivant pour définir la variable $GITLAB_HOME.

GITLAB_HOME=/opt/gitlab/vol

Le conteneur Gitlab utilise des volumes montés sur l'hôte pour stocker les données persistantes. Le tableau suivant montre le mappage de l'emplacement local des répertoires Gitlab avec l'emplacement des conteneurs et leur utilisation respective.

Étape 5 - Installez Gitlab à l'aide de Docker Compose

Assurez-vous que vous êtes dans le répertoire de composition Docker de Gitlab.

Créez et ouvrez le fichier de configuration Docker Compose pour le modifier.

nano docker-compose.yml

Collez-y le code suivant.

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 '
        gitlab_rails['gitlab_email_reply_to'] = '[email '
        # 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'

Jetons un coup d'œil à toutes les options définies dans le fichier.

• image fait référence à l'emplacement de l'image Docker de Gitlab sur Dockerhub.
• container_name vous permet d'appliquer une étiquette à votre conteneur Docker, à utiliser lors du référencement du conteneur au sein d'un réseau Docker.
• restart spécifie une politique de redémarrage pour le conteneur. Le définir sur toujours signifie qu'un conteneur, s'il est quitté, sera automatiquement redémarré.
• hostname définit le nom d'hôte interne du conteneur ou dans ce cas, l'URL où votre Gitlab sera installé.
• L'environnement fournit la variable GITLAB_OMNIBUS_CONFIG qui vous permet de saisir n'importe quel paramètre de configuration Gitlab.
• external_url fait référence au domaine sur lequel votre Gitlab sera installé. L'utilisation du protocole https garantit l'installation automatique du certificat SSL Let's Encrypt.
• Détails SMTP : nous avons inclus les détails SMTP afin que l'instance Gitlab puisse envoyer des e-mails et des notifications importants. Pour notre tutoriel, nous utilisons le service SES d'Amazon. Vous pouvez cependant utiliser n'importe quel service de votre choix. Consultez la documentation Gitlab sur les mailers SMTP pour savoir comment les configurer.
• Les ports indiquent au conteneur de publier des ports ou une plage de ports sur l'hôte. Étant donné que Gitlab a besoin des ports 22 (SSH), 80 (HTTP), 443 (HTTPS) et 587 (SMTP), ils ont été exposés au système. Si vous souhaitez que Gitlab utilise un port non standard sur votre serveur (probablement parce qu'il n'est pas disponible), vous devez d'abord fournir le port hôte, puis le port conteneur. Par exemple, puisque votre serveur utilise déjà le port SSH(22), vous pouvez demander à Gitlab d'utiliser SSH via un port différent, par exemple 3333. Ensuite, vous remplacerez 22:22 dans le fichier ci-dessus par 3333:22. Vous devrez également ajouter la ligne gitlab_rails['gitlab_shell_ssh_port']=3333 sous GITLAB_OMNIBUS_CONFIG ci-dessus.
• volume définit les répertoires présents sur le serveur pour stocker les données persistantes. Comme défini à l'étape 5, $GITLAB_HOME peut désormais être utilisé dans le fichier de composition pour monter les répertoires pertinents sur le conteneur.
• shm_size fait référence à la mémoire partagée utilisée par le conteneur. Par défaut, Docker alloue 64 Mo au répertoire de mémoire partagée (monté sur /dev/shm). Cela peut s'avérer insuffisant pour les métriques Prometheus générées par le conteneur Gitlab. Ainsi, un minimum de 256 Mo de mémoire partagée assure le bon fonctionnement du docker. Vous pouvez augmenter sa valeur en fonction de la RAM dont dispose votre système. Vous pouvez également désactiver les métriques Prometheus depuis la zone d'administration après l'installation. Nous explorerons cela à l’étape suivante.

Démarrez le conteneur Gitlab Docker.

docker compose up -d

Le processus prendra quelques minutes. Vous pouvez suivre la progression à l'aide des journaux Docker.

docker logs gitlab-howtoforge -f

Appuyez sur Ctrl + C pour quitter le suivi du journal.

Vous pouvez vérifier l'état du conteneur Gitlab à l'aide de la commande suivante.

docker ps

Gitlab génère automatiquement un mot de passe root et le stocke dans le fichier initiall_root_password. Ce fichier se trouve dans le répertoire /srv/gitlab/config. Exécutez la commande suivante pour afficher le mot de passe root.

cat /opt/gitlab/vol/config/initial_root_password

Vous recevrez un résultat similaire.

# 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.

Copiez le mot de passe et enregistrez-le pour une utilisation ultérieure. Maintenant que tout est configuré, nous pouvons procéder à la configuration.

Étape 6 - Configurer Gitlab

Accéder à Gitlab

Ouvrez l'URL https://gitlab.example.com dans votre navigateur et vous obtiendrez l'écran de connexion suivant.

Saisissez root comme nom d'utilisateur et mot de passe que vous avez obtenus à l'étape précédente pour vous connecter à votre tableau de bord Gitlab. Une fois connecté, vous serez redirigé vers l’écran de tableau de bord suivant.

Comme vous pouvez le voir, Gitlab a déjà créé un projet pour surveiller l'instance.

Restreindre les inscriptions publiques

Par défaut, n'importe qui peut créer un compte et y accéder. Si vous ne le souhaitez pas, vous pouvez le désactiver. Heureusement, le paramètre correspondant est affiché sous la forme d’un écran contextuel sur le tableau de bord. Cliquez sur le bouton Désactiver pour restreindre les inscriptions publiques sur votre instance Gitlab. Cela vous redirigera vers la page de paramètres suivante.

Décochez l'option Inscription activée pour les restreindre. Appuyez sur le bouton Enregistrer les modifications pour appliquer le paramètre.

Si vous ne voyez pas la fenêtre contextuelle dans votre tableau de bord, vous pouvez accéder à la page des paramètres en cliquant sur le bouton Menu et en accédant au panneau d'administration à partir de là.

Une fois dans le panneau d'administration, passez votre souris sur l'option Paramètres dans la barre latérale gauche et cliquez sur le sous-menu Général. De là, vous pouvez accéder au panneau Restrictions d'inscription.

Configurer le profil Gitlab

Votre profil par défaut est vide et n’a rien à afficher. Pour modifier cela, cliquez sur l'icône de l'utilisateur dans le coin supérieur gauche pour afficher le menu déroulant et sélectionnez l'option Modifier le profil.

Vous serez redirigé vers la page des paramètres de profil où vous pourrez ajouter votre nom, votre adresse e-mail et d'autres informations vous concernant. Cliquez sur Mettre à jour les paramètres du profil lorsque vous avez terminé. Ne retournez pas à la page d'accueil car nous avons d'autres éléments à configurer ici.

Changer le mot de passe racine

C’est l’une des étapes les plus importantes. Vous devez modifier votre mot de passe root par défaut immédiatement. Avec les versions antérieures, Gitlab vous obligeait à le modifier dans le cadre de l'installation, mais il le rend désormais facultatif. Pour modifier votre mot de passe, cliquez sur le menu Mot de passe dans la barre latérale gauche.

Saisissez les détails de votre mot de passe et cliquez sur Enregistrer le mot de passe pour effectuer la modification. Vous serez déconnecté de votre instance et devrez vous reconnecter.

Changer le nom d'utilisateur

Vous pouvez changer votre nom d'utilisateur Gitlab par défaut de root à celui de votre choix. Pour ce faire, cliquez sur le menu Compte dans la barre latérale gauche.

Une fois sur la page, saisissez votre nouveau nom d'utilisateur et cliquez sur le bouton Mettre à jour le nom d'utilisateur pour effectuer la modification. Vous serez à nouveau invité à confirmer. Appuyez à nouveau sur le bouton Mettre à jour le nom d'utilisateur pour confirmer la modification.

Vous devez également activer ici l'authentification à deux facteurs pour améliorer la sécurité de votre compte.

Désactivez les métriques Prometheus et améliorez la confidentialité

À l'étape précédente, nous avons discuté de l'augmentation de la taille de la mémoire partagée pour le droplet et de son maintien à un minimum de 256 Mo. Il est principalement nécessaire pour stocker les données liées aux métriques Prometheus sur le disque. Si vous n'utilisez pas la fonctionnalité, vous devez la désactiver. Vous ne pouvez le faire qu'après l'installation. Pour le désactiver, ouvrez le Panneau d'administration depuis la barre de menu.

Une fois dans le panneau d'administration, ouvrez l'option de menu Paramètres >> Métriques et profilage.

Développez la section Métriques - Prometheus sur la page Métriques et décochez l'option Activer le point de terminaison des métriques d'intégrité et de performances. Cliquez sur le bouton Enregistrer les modifications pour appliquer la modification.

Gitlab collecte également des informations d'utilisation à partir de chaque installation. Si vous accordez de l'importance à la confidentialité et que vous ne souhaitez pas que cela se produise, développez l'option Statistiques d'utilisation sur la même page et décochez l'option Activer le ping du service. Cliquez sur le bouton Enregistrer les modifications pour appliquer la modification.

Étape 7 - Création de votre premier projet

Essayons de créer notre premier projet et de pousser un commit.

Ajouter votre clé SSH

Avant d'aller plus loin, nous devons ajouter notre clé SSH. Cela nous permet d'interagir avec notre installation sans utiliser de mot de passe. Si vous disposez d'une clé SSH, vous pouvez ignorer la commande suivante. Si vous n'en avez pas, vous pouvez en créer un à l'aide de la commande suivante.

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

Cette commande est commune à macOS, Linux et Git Bash/WSL sous Windows. Acceptez les valeurs par défaut et saisissez une phrase secrète forte. Nous créons les clés SSH sur le terminal Windows Powershell.

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]-----+

Ajoutez l'identité de clé privée à l'agent d'authentification SSH. Assurez-vous que le service OpenSSH Authentication Agent est en cours d'exécution si vous êtes sous Windows. Si vous êtes sous Linux ou macOS, exécutez la commande suivante.

$ eval $(ssh-agent -s)

Ajoutez la clé.

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

Sous Linux et macOS, la commande deviendra

$ ssh-add ~/.ssh/id_ed25519

Vous serez invité à saisir la phrase secrète. Entrez-le et la clé sera ajoutée.

Ensuite, nous devons enregistrer ces paramètres dans le fichier ~/.ssh/config. Sous Windows, ce sera le répertoire C:\Users\\.ssh. Collez le code suivant à la fin du fichier.

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

Dans ce fichier, le nom du chemin restera le même sur tous les systèmes d'exploitation. Enregistrez le fichier.

Ensuite, nous devons copier la clé publique sur notre compte Gitlab. Vous pouvez afficher votre clé publique via la commande suivante. Le nom du chemin fonctionnera à nouveau sur tous les systèmes d'exploitation ici.

$ cat ~/.ssh/id_ed25519.pub

Vous obtiendrez un résultat similaire.

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAml2KPhmGkdMWv7jksLKO13u3g1zI9CumKDQSpv7lYh gitlab.example.com

Ouvrez les paramètres de votre profil dans Gitlab et sélectionnez le menu Clés SSH dans la barre latérale gauche.

Collez la clé SSH dans la case prévue et cliquez sur Ajouter une clé pour continuer.

Ensuite, nous devons tester si notre connexion SSH fonctionne correctement. Exécutez la commande suivante sur votre terminal PC.

$ ssh -T [email 

Vous obtiendrez un résultat similaire. Tout d'abord, il vous sera demandé d'ajouter la clé SSH à la liste des hôtes connus de votre système. Tapez oui pour continuer. Vous recevrez également un avertissement indiquant que la clé SSH de l'instance Gitlab et l'adresse IP de votre serveur ne sont pas les mêmes et il vous sera à nouveau demandé si vous souhaitez continuer. Tapez à nouveau oui. Enfin, vous recevrez un message de réussite confirmant votre connexion à votre instance 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!

Maintenant, nous pouvons passer à la création de notre premier référentiel et effectuer quelques validations.

Créer un projet

Chaque référentiel dans Gitlab appartient à un projet. Un projet comprend un référentiel, un suivi des problèmes, des demandes de fusion, un wiki, des pipelines d'intégration continue et de livraison continue (CI/CD) et de nombreuses autres fonctionnalités.

Pour créer votre premier dépôt, cliquez sur le bouton Nouveau projet sur votre page d'accueil.

Vous serez redirigé vers la page Nouveau projet où vous aurez plusieurs options sur la façon de créer un nouveau projet.

Sélectionnez l'option Créer un projet vierge pour continuer. Sur la page suivante, entrez le nom du projet. Sélectionnez votre nom d'utilisateur dans le menu déroulant de l'option URL du projet. Définissez le slug de votre projet. Entrez une description du projet si vous le souhaitez et modifiez la visibilité du projet selon vos besoins. Vous pouvez initialiser votre référentiel avec un fichier README.

Une fois que vous avez terminé, cliquez sur Créer un projet. Vous serez redirigé vers la page de votre référentiel avec un seul fichier README.md vierge.

Maintenant que notre référentiel est en ligne, essayons d'ajouter un journal des modifications à partir de la ligne de commande. Entrez les commandes suivantes sur votre ordinateur pour créer un fichier CHANGELOG et le renvoyer vers votre référentiel. Assurez-vous que Git est installé sur votre ordinateur.

La première étape consiste à cloner le référentiel. Vous pouvez cloner en utilisant SSH ou HTTPS. Clonez en utilisant SSH. Il vous sera demandé la phrase secrète.

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

Entrez le reste des commandes pour créer et transmettre le fichier 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

Vous serez à nouveau invité à saisir la phrase secrète lors de la commande push.

Revenez à la page de votre projet Gitlab et vous y verrez le fichier CHANGELOG. Toutes nos félicitations! Vous avez créé avec succès votre premier projet et y avez validé un fichier.

Étape 8 - Gérer le conteneur Gitlab

Voyons comment vous pouvez gérer le conteneur Gitlab à l'aide de commandes simples.

Si, à tout moment, vous souhaitez arrêter le conteneur, exécutez la commande suivante depuis le répertoire de composition Docker.

$ docker compose down

Pour les redémarrer, exécutez la commande suivante.

$ docker compose up -d

Si vous souhaitez modifier un paramètre ou ajouter un paramètre à votre instance Gitlab, vous pouvez le faire en modifiant le fichier docker-compose.yml sous la variable GITLAB_OMNIBUS_CONFIG. Une fois votre modification effectuée, vous devrez redémarrer le conteneur pour mettre en œuvre la modification. Exécutez les commandes suivantes pour mettre à jour le conteneur avec la nouvelle configuration.

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

Pour redémarrer le conteneur, exécutez la commande suivante. Cependant, la commande de redémarrage suivante ne prend en compte aucune modification apportée au fichier de composition Docker.

$ docker compose restart

Accédez au shell du conteneur.

$ docker exec -it <container name> bash

Étape 9 - Sauvegarder Gitlab

La sauvegarde de Gitlab peut être effectuée via une seule commande.

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

Le fichier de sauvegarde est enregistré dans le répertoire /srv/gitlab/data/backups. Cette sauvegarde ne contient pas votre fichier de configuration gitlab-secrets.json. Ce fichier se trouve dans le répertoire /srv/gitlab/config. Par conséquent, vous devez sauvegarder ce fichier séparément. Il existe un autre fichier de configuration, gitlab.rb, qui contient tous les paramètres de l'instance Gitlab. Mais dans notre cas, nous avons utilisé la variable GITLAB_OMNIBUS_CONFIG dans notre fichier de composition, ce fichier n'est donc pas utilisé par Gitlab. Pour apporter des modifications à Gitlab, vous devrez les définir via la variable. Par conséquent, vous devrez également sauvegarder le fichier de composition.

Vous pouvez créer une entrée cron pour sauvegarder régulièrement votre installation Gitlab.

Étape 10 - Restaurer Gitlab

Pour restaurer Gitlab, vous devez disposer d'une installation Gitlab fonctionnelle sur un autre système. Vous devrez également copier votre répertoire de configuration et écraser la configuration de l'installation existante.

La restauration de Gitlab nécessite l'exécution de plusieurs commandes. Tout d'abord, vous devez arrêter les processus connectés à la base de données.

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

Remplacez par le nom du conteneur sur votre nouveau serveur.

Vérifiez que les processus sont arrêtés avant de continuer.

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

Copiez le fichier de sauvegarde dans le répertoire /srv/gitlab/data/backups. Créez le répertoire s'il n'existe pas.

Exécutez la commande de restauration. Vous devez supprimer la partie _gitlab_backup.tar du nom de fichier de la commande.

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

Copiez le fichier gitlab-secrets.json et écrasez la copie existante dans le répertoire /srv/gitlab/config du nouveau serveur. Copiez également tous les paramètres Gitlab du fichier de composition sauvegardé vers le fichier du conteneur le plus récent.

Redémarrez le conteneur Gitlab. Nous ne pouvons pas utiliser directement la commande docker compose restart car elle ne sélectionnera aucune modification apportée au fichier de composition dont nous avons besoin.

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

Vérifiez Gitlab.

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

Étape 11 - Mettre à niveau Gitlab

Pour mettre à niveau Gitlab, la première étape consiste à effectuer une sauvegarde comme indiqué lors de l'arrêt précédent.

Ensuite, passez au répertoire de composition Docker de Gitlab.

$ cd ~/gitlab-docker

Ensuite, arrêtez et supprimez le conteneur existant. Vos données seront cependant conservées.

$ docker compose down --remove-orphans

Extrayez la dernière version de l’image docker Gitlab.

$ docker compose pull

Redémarrez les conteneurs.

$ docker compose up -d

Ce processus convient à la mise à niveau entre des versions mineures de Gitlab, mais lorsque vous effectuez une mise à niveau vers une version majeure, vous devez suivre des étapes supplémentaires et prendre des précautions. Vous devez vous référer à la documentation de Gitlab avant d'effectuer la mise à niveau.

Conclusion

Ceci conclut notre didacticiel, dans lequel vous avez appris à installer Gitlab à l'aide de Docker sur un serveur Debian 12. Vous avez également créé votre premier projet et soumis un fichier depuis votre PC. Si vous avez des questions, postez-les dans les commentaires ci-dessous.