So installierst du GitLab mit Docker auf Ubuntu 22.04

Gitlab Server ist eine Open-Source-Version der Cloud-gehosteten Versionskontrolle Gitlab. Der Vorteil des Selbst-Hostings deiner Repositories gegenüber dem Cloud-Hosting ist die vollständige Kontrolle über deinen Code.

In dieser Anleitung lernst du, wie du Gitlab Server mit Docker auf einem Ubuntu 22.04 Server installierst. Gitlab Server bietet zwei Editionen an – die kostenlose Community Edition und die kostenpflichtige Enterprise Edition. Wir werden die Community-Edition installieren. Wenn du mehr Funktionen möchtest, kannst du einfach auf die Enterprise Edition upgraden.

Voraussetzungen

• Ein Server, auf dem Ubuntu 22.04 läuft.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
• Ein Fully Qualified Domain Name (FQDN), der auf den Server zeigt, z. B. gitlab.example.com.

Alles ist auf dem neuesten Stand.

$ sudo apt update && sudo apt upgrade

Schritt 1 – Firewall konfigurieren

Der erste Schritt vor der Installation der Pakete besteht darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

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

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Öffne Port 587 für den Empfang von Mails über SMTP. Möglicherweise verwendest du einen anderen Port für deinen SMTP-Mailer.

$ sudo ufw allow http
$ sudo ufw allow 587

Überprüfe den Status zur Bestätigung noch einmal.

$ 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)

Schritt 2 – Abhängigkeiten installieren

Bevor wir Gitlab installieren, müssen wir bestimmte Pakete installieren, die wir im Laufe des Tutorials benötigen.

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

Einige dieser Pakete sind vielleicht schon auf deinem System vorinstalliert.

Schritt 3 – Ändern des SSH-Ports des Systems

Gitlab verwendet den Standard-SSH-Port, der mit dem SSH-Port deines Systems kollidieren kann. Um die besten Ergebnisse zu erzielen, ist es besser, den Standard-Port des Systems zu ändern.

Dazu öffnest du die Datei /etc/ssh/sshd_config und bearbeitest sie.

$ sudo nano /etc/ssh/sshd_config

Suche die folgende Zeile, entferne die Raute (#) davor und ändere den Wert von 22 in einen Wert deiner Wahl. Für unser Lernprogramm haben wir 2425 gewählt, indem wir

#Port 22

in ändern.

 Port 2425

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den SSH-Dienst neu.

$ sudo systemctl restart sshd

Öffne Port 2425 in der Firewall.

$ sudo ufw allow 2425

Beende deine aktuelle SSH-Sitzung und melde dich mit dem neuen Port erneut an.

$ ssh username@<serverIP> -p 2425

Schritt 4 – Installiere Docker und Docker Compose

Füge den offiziellen GPG-Schlüssel von Docker hinzu.

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

Führe den folgenden Befehl aus, um das Docker-Repository hinzuzufügen.

$ 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

Aktualisiere das System, um das Docker-Repository einzubinden.

$ sudo apt update

Installiere Docker.

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

In diesem Lehrgang wird das Docker Compose v2 Plugin anstelle des älteren Legacy Binary verwendet. Daher hat sich der Befehl zum Ausführen von docker-compose zu docker compose geändert, was sich hier widerspiegelt.

Docker läuft mit erhöhten Rechten, daher musst du sudo häufig verwenden, um Befehle auszuführen. Die bessere Option ist, dein Linux-Benutzerkonto zur Benutzergruppe docker hinzuzufügen.

$ sudo usermod -aG docker ${USER}

Die Variable ${USER} nimmt das aktuell eingeloggte Systemkonto auf. Wenn du nicht mit dem Benutzer eingeloggt bist, dem du Privilegien geben willst, ersetze ${USER} durch den Benutzernamen.

Um die neue Gruppenmitgliedschaft zu beantragen, melde dich vom Server ab und wieder an oder verwende den folgenden Befehl. Du wirst aufgefordert, das Passwort des Benutzers einzugeben.

$ su - $(USER)

Schritt 5 – Docker Volumes einrichten

Bevor wir mit der Installation fortfahren, müssen wir den Speicherort für Gitlab-Daten und -Konfigurationen festlegen, auf die über Docker-Volumes zugegriffen werden soll.

Erstelle das Verzeichnis für das Docker-Volume.

$ sudo mkdir /srv/gitlab -p

Erstelle ein Verzeichnis für die Docker Compose-Datei.

$ mkdir ~/gitlab-docker

Wechsle in das Verzeichnis.

$ cd ~/gitlab-docker

Erstelle eine Umgebungsvariablendatei und öffne sie zur Bearbeitung.

$ nano .env

Füge den folgenden Code ein, um die Variable $GITLAB_HOME zu definieren.

GITLAB_HOME=/srv/gitlab

Der Gitlab-Container verwendet vom Host gemountete Volumes, um persistente Daten zu speichern. Die folgende Tabelle zeigt die Zuordnung zwischen dem lokalen Speicherort der Gitlab-Verzeichnisse und dem Speicherort der Container sowie deren jeweilige Verwendung.

Lokaler Speicherort	Container-Speicherort	Verwendung
$GITLAB_HOME/data	/var/opt/gitlab	Zum Speichern von Anwendungsdaten.
$GITLAB_HOME/logs	/var/log/gitlab	Zum Speichern von Protokollen.
$GITLAB_HOME/config	/etc/gitlab	Zum Speichern der Gitlab-Konfiguration.

Schritt 6 – Gitlab mit Docker Compose installieren

Vergewissere dich, dass du dich im Docker Compose-Verzeichnis von Gitlab befindest.

Erstelle und öffne die Docker Compose Konfigurationsdatei zum Bearbeiten.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

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'] = 'gitlab@example.com'
        gitlab_rails['gitlab_email_reply_to'] = 'noreply@example.com'
        # 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'

Schauen wir uns alle Optionen an, die in der Datei definiert sind.

• image verweist auf den Speicherort des Docker-Images von Gitlab auf Dockerhub.
• container_name ermöglicht es dir, deinem Docker-Container ein Label zu geben, wenn du den Container innerhalb eines Docker-Netzwerks referenzieren willst.
• restart legt eine Neustart-Richtlinie für den Container fest. Die Einstellung “ always“ bedeutet, dass ein Container automatisch neu gestartet wird, wenn er verlassen wird.
• hostname legt den internen Hostnamen des Containers fest oder in diesem Fall die URL, unter der dein Gitlab installiert wird.
• environment liefert die Variable GITLAB_OMNIBUS_CONFIG, mit der du alle Gitlab-Konfigurationseinstellungen eingeben kannst.
• external_url verweist auf die Domain, auf der dein Gitlab installiert wird. Die Verwendung des https Protokolls sorgt für die automatische Installation des Let’s Encrypt SSL-Zertifikats.
• SMTP-Details – wir haben SMTP-Details angegeben, damit die Gitlab-Instanz wichtige E-Mails und Benachrichtigungen versenden kann. Für unser Tutorial verwenden wir den SES-Dienst von Amazon. Du kannst aber auch einen anderen Dienst deiner Wahl verwenden. In der Gitlab-Dokumentation für SMTP-Mailer erfährst du, wie du sie konfigurierst.
• Ports weisen den Container an, Ports oder eine Reihe von Ports auf dem Host zu veröffentlichen. Da Gitlab die Ports 22 (SSH), 80 (HTTP), 443 (HTTPS) und 587 (SMTP) benötigt, sind sie dem System bekannt gegeben worden. Wenn du möchtest, dass Gitlab einen nicht standardisierten Port auf deinem Server verwendet (wahrscheinlich, weil er nicht verfügbar ist), musst du zuerst den Host-Port und dann den Container-Port angeben. Da dein Server zum Beispiel bereits den SSH(22)-Port verwendet, kannst du Gitlab mitteilen, dass es SSH über einen anderen Port verwenden soll, zum Beispiel 3333. Dann würdest du 22:22 in der obigen Datei in 3333:22 ändern. Außerdem musst du die Zeile gitlab_rails['gitlab_shell_ssh_port'] = 3333 unter GITLAB_OMNIBUS_CONFIG hinzufügen.
• volume definiert die Verzeichnisse, die auf dem Server vorhanden sind, um persistente Daten zu speichern. Wie in Schritt 5 definiert, kann $GITLAB_HOME nun in der Compose-Datei verwendet werden, um die entsprechenden Verzeichnisse auf dem Container einzuhängen.
• shm_size bezieht sich auf den vom Container verwendeten gemeinsamen Speicher. Standardmäßig weist Docker dem Shared-Memory-Verzeichnis (eingehängt unter /dev/shm) 64 MB zu. Das kann für die Prometheus-Metriken, die der Gitlab-Container generiert, zu wenig sein. Daher sorgt ein Minimum von 256 MB an gemeinsamem Speicher für einen reibungslosen Betrieb von Docker. Je nachdem, wie viel Arbeitsspeicher dein System hat, kannst du diesen Wert erhöhen. Alternativ kannst du die Prometheus-Metriken nach der Installation im Admin-Bereich deaktivieren. Wir werden dies im nächsten Schritt untersuchen.

Starte den Gitlab-Docker-Container.

$ docker compose up -d

Es wird ein paar Minuten dauern, bis der Prozess abgeschlossen ist. Du kannst den Fortschritt anhand der Docker-Logs verfolgen.

$ docker logs gitlab-howtoforge -f

Drücke Strg + C, um die Überwachung der Logs zu beenden.

Du kannst den Status des Gitlab-Containers mit dem folgenden Befehl überprüfen.

$ docker ps

Ab Gitlab 14.0 wird automatisch ein Root-Passwort generiert und in der Datei initiall_root_password gespeichert. Diese Datei findest du im Verzeichnis /srv/gitlab/config. Führe den folgenden Befehl aus, um das Root-Passwort einzusehen.

$ sudo cat /srv/gitlab/config/initial_root_password

Du wirst eine ähnliche Ausgabe erhalten.

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

Kopiere das Passwort und speichere es zur späteren Verwendung. Da nun alles eingerichtet ist, können wir mit der Konfiguration fortfahren.

Schritt 7 – Gitlab konfigurieren

Zugriff auf Gitlab

Öffne die URL https://gitlab.example.com in deinem Browser und du erhältst den folgenden Anmeldebildschirm.

Gib root als Benutzernamen und das Passwort ein, das du im vorherigen Schritt erhalten hast, um dich bei deinem Gitlab-Dashboard anzumelden. Nachdem du dich angemeldet hast, erscheint der folgende Dashboard-Bildschirm.

Wie du siehst, hat Gitlab bereits ein Projekt erstellt, um die Instanz zu überwachen.

Öffentliche Anmeldungen einschränken

In der Standardeinstellung kann jeder ein Konto erstellen und Zugang erhalten. Wenn du das nicht möchtest, kannst du es ausschalten. Glücklicherweise wird die Einstellung dafür in Form eines Pop-up-Fensters auf dem Dashboard angezeigt. Klicke auf die Schaltfläche Deaktivieren, um öffentliche Anmeldungen auf deiner Gitlab-Instanz zu beschränken. Daraufhin wirst du auf die folgende Einstellungsseite weitergeleitet.

Deaktiviere die Option Sign-up aktiviert, um sie einzuschränken. Klicke auf die Schaltfläche Änderungen speichern, um die Einstellung zu übernehmen.

Falls du das Pop-up nicht in deinem Dashboard siehst, kannst du die Einstellungsseite aufrufen, indem du auf die Schaltfläche Menü klickst und von dort aus das Admin-Panel öffnest.

Wenn du dich im Verwaltungsbereich befindest, fahre mit der Maus über die Option Einstellungen in der linken Seitenleiste und klicke auf das Untermenü Allgemein. Von dort aus gelangst du zum Bereich Anmeldebeschränkungen.

Gitlab-Profil konfigurieren

Dein Standardprofil ist ziemlich unscheinbar und hat nichts zu bieten. Um das zu ändern, klicke auf das Benutzersymbol in der oberen linken Ecke, um das Dropdown-Menü aufzurufen, und wähle die Option Profil bearbeiten.

Du gelangst zur Seite mit den Profileinstellungen, wo du deinen Namen, deine E-Mail-Adresse und andere Informationen über dich hinzufügen kannst. Klicke auf Profileinstellungen aktualisieren, wenn du fertig bist. Gehe nicht zurück zur Startseite, denn hier gibt es noch einige Dinge zu konfigurieren.

Root-Passwort ändern

Dies ist einer der wichtigsten Schritte. Du solltest dein Standard-Root-Passwort sofort ändern. In früheren Versionen musste man es bei der Installation ändern, aber jetzt ist es optional. Um dein Passwort zu ändern, klicke in der linken Seitenleiste auf das Menü Passwort.

Gib deine Passwortdaten ein und klicke auf Passwort speichern, um die Änderung vorzunehmen. Du wirst von deiner Instanz abgemeldet und musst dich erneut anmelden.

Benutzernamen ändern

Du kannst deinen Standardbenutzernamen bei Gitlab von root in einen beliebigen Namen deiner Wahl ändern. Klicke dazu auf das Menü Konto in der linken Seitenleiste.

Auf der Seite gibst du deinen neuen Benutzernamen ein und klickst auf die Schaltfläche Benutzernamen aktualisieren, um die Änderung vorzunehmen. Du wirst erneut zur Bestätigung aufgefordert. Klicke erneut auf die Schaltfläche Benutzername aktualisieren, um die Änderung zu bestätigen.

Du solltest hier auch die Zwei-Faktor-Authentifizierung aktivieren, um die Sicherheit deines Kontos zu erhöhen.

Deaktiviere Prometheus Metrics und verbessere die Privatsphäre

Im vorherigen Schritt haben wir besprochen, dass du den gemeinsamen Speicher für das Droplet auf mindestens 256 MB erhöhen sollst. Er wird hauptsächlich benötigt, um die Prometheus Metrics-bezogenen Daten auf der Festplatte zu speichern. Wenn du die Funktion nicht nutzt, solltest du sie deaktivieren. Das kannst du nur nach der Installation tun. Um sie zu deaktivieren, öffne das Admin Panel in der Menüleiste.

Im Admin Panel öffnest du den Menüpunkt Einstellungen >> Metriken und Profilerstellung.

Erweitere auf der Seite Metriken den Abschnitt Metriken – Prometheus und entferne das Häkchen bei der Option Endpunkt für Gesundheits- und Leistungsmetriken aktivieren. Klicke auf die Schaltfläche Änderungen speichern, um die Änderung zu übernehmen.

Gitlab sammelt auch Nutzungsdaten von jeder Installation. Wenn du Wert auf deine Privatsphäre legst und das nicht möchtest, erweitere die Option Nutzungsstatistiken auf derselben Seite und entferne das Häkchen bei der Option Service Ping aktivieren. Klicke auf die Schaltfläche Änderungen speichern, um die Änderung zu übernehmen.

Schritt 8 – Dein erstes Projekt erstellen

Lass uns versuchen, unser erstes Projekt zu erstellen und einen Commit zu machen.

Hinzufügen deines SSH-Schlüssels

Bevor wir weitermachen, sollten wir unseren SSH-Schlüssel hinzufügen. So können wir mit unserer Installation interagieren, ohne Passwörter zu verwenden. Wenn du einen SSH-Schlüssel hast, kannst du den folgenden Befehl überspringen. Wenn du noch keinen hast, kannst du ihn mit dem folgenden Befehl erstellen.

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

Dieser Befehl ist für macOS, Linux und Git Bash/WSL unter Windows üblich. Akzeptiere die Standardeinstellungen und gib eine starke Passphrase ein. Wir erstellen die SSH-Schlüssel im Windows Powershell Terminal.

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

Füge die Identität des privaten Schlüssels zum SSH-Authentifizierungsagenten hinzu. Vergewissere dich, dass der OpenSSH-Authentifizierungsagent-Dienst unter Windows läuft. Wenn du unter Linux oder macOS arbeitest, führe den folgenden Befehl aus.

$ eval $(ssh-agent -s)

Füge den Schlüssel hinzu.

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

Unter Linux und macOS ändert sich der Befehl in

$ ssh-add ~/.ssh/id_ed25519

Du wirst zur Eingabe der Passphrase aufgefordert. Gib sie ein und der Schlüssel wird hinzugefügt.

Als Nächstes müssen wir diese Einstellungen in der Datei ~/.ssh/config speichern. Unter Windows wird dies das Verzeichnis C:\Users\<username>\.ssh sein. Füge den folgenden Code am Ende der Datei ein.

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

In dieser Datei bleibt der Pfadname auf allen Betriebssystemen gleich. Speichere die Datei.

Als Nächstes müssen wir den öffentlichen Schlüssel in unser Gitlab-Konto kopieren. Du kannst dir deinen öffentlichen Schlüssel mit dem folgenden Befehl anzeigen lassen. Auch hier funktioniert der Pfadname über alle Betriebssysteme hinweg.

$ cat ~/.ssh/id_ed25519.pub

Du wirst eine ähnliche Ausgabe erhalten.

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAml2KPhmGkdMWv7jksLKO13u3g1zI9CumKDQSpv7lYh gitlab.example.com

Öffne deine Profileinstellungen in Gitlab und wähle das Menü SSH-Schlüssel in der linken Seitenleiste.

Füge den SSH-Schlüssel in das dafür vorgesehene Feld ein und klicke auf Schlüssel hinzufügen, um fortzufahren.

Als Nächstes müssen wir testen, ob unsere SSH-Verbindung erfolgreich funktioniert. Führe den folgenden Befehl im Terminal deines PCs aus.

$ ssh -T git@gitlab.example.com

Du wirst eine ähnliche Ausgabe erhalten. Zuerst wirst du gefragt, ob du den SSH-Schlüssel zur Liste der bekannten Hosts deines Systems hinzufügen möchtest. Gib Ja ein, um fortzufahren. Du erhältst auch eine Warnung, dass der SSH-Schlüssel für die Gitlab-Instanz und die IP deines Servers nicht übereinstimmen und wirst erneut gefragt, ob du fortfahren möchtest. Gib erneut Ja ein. Schließlich erhältst du eine Erfolgsmeldung, die deine Verbindung zu deiner Gitlab-Instanz bestätigt.

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!

Jetzt können wir unser erstes Repository erstellen und einige Übertragungen vornehmen.

Ein Projekt erstellen

Jedes Projektarchiv in Gitlab gehört zu einem Projekt. Zu einem Projekt gehören ein Projektarchiv, ein Issue Tracker, Merge Requests, ein Wiki, Continuous Integration und Continuous Delivery (CI/CD) Pipelines und viele andere Funktionen.

Um dein erstes Repository zu erstellen, klicke auf die Schaltfläche Neues Projekt auf deiner Homepage.

Du wirst auf die Seite Neues Projekt weitergeleitet, auf der du mehrere Möglichkeiten hast, ein neues Projekt zu erstellen.

Wähle die Option Leeres Projekt erstellen, um fortzufahren. Auf der nächsten Seite gibst du den Projektnamen ein. Wähle deinen Benutzernamen aus dem Dropdown-Menü unter der Option Projekt-URL. Lege deinen Projekt-Slug fest. Gib eine Beschreibung des Projekts ein, wenn du möchtest, und ändere die Sichtbarkeit des Projekts nach deinem Bedarf. Du kannst dein Projektarchiv mit einer README Datei zu initialisieren.

Wenn du fertig bist, klicke auf Projekt erstellen. Du wirst zu deiner Projektarchivseite mit einer einzigen leeren README.md Datei weiter geleitet.

Jetzt, wo unser Projektarchiv live ist, wollen wir versuchen, ein Änderungsprotokoll über die Befehlszeile hinzuzufügen. Gib die folgenden Befehle auf deinem Computer ein, um eine CHANGELOG Datei zu erstellen und sie in dein Projektarchiv zu übertragen. Stelle sicher, dass du Git auf deinem Computer installiert hast.

Der erste Schritt besteht darin, das Repository zu klonen. Du kannst entweder mit SSH oder HTTPS klonen. Klone mit SSH. Du wirst nach der Passphrase gefragt.

$ git clone git@gitlab.example.com:user/howtoforge-test.git

Gib den Rest der Befehle ein, um die Datei CHANGELOG zu erstellen und zu pushen.

$ 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

Während des Push-Befehls wirst du erneut zur Eingabe der Passphrase aufgefordert.

Gehe zurück zu deiner Gitlab-Projektseite und du wirst die Datei CHANGELOG sehen. Herzlichen Glückwunsch! Du hast erfolgreich dein erstes Projekt erstellt und eine Datei in das Projekt übertragen.

Schritt 9 – Verwalten des Gitlab-Containers

Wir wollen sehen, wie du den Gitlab-Container mit einfachen Befehlen verwalten kannst.

Wenn du den Container zu irgendeinem Zeitpunkt anhalten möchtest, gibst du den folgenden Befehl aus dem Docker compose Verzeichnis heraus ein.

$ docker compose down

Um ihn wieder zu starten, gibst du den folgenden Befehl ein.

$ docker compose up -d

Wenn du eine Einstellung ändern oder eine Einstellung zu deiner Gitlab-Instanz hinzufügen möchtest, kannst du das tun, indem du die Datei docker-compose.yml unter der Variable GITLAB_OMNIBUS_CONFIG bearbeitest. Sobald du deine Änderungen vorgenommen hast, musst du den Container neu starten, um die Änderungen umzusetzen. Gib die folgenden Befehle ein, um den Container mit der neuen Konfiguration zu aktualisieren.

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

Um den Container neu zu starten, gibst du den folgenden Befehl ein. Der folgende Neustart-Befehl übernimmt allerdings keine Änderungen, die an der Docker-Compose-Datei vorgenommen wurden.

$ docker compose restart

Rufe die Shell des Containers auf.

$ docker exec -it <container name> bash

Schritt 10 – Gitlab sichern

Die Sicherung von Gitlab kann mit einem einzigen Befehl durchgeführt werden.

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

Die Sicherungsdatei wird im Verzeichnis /srv/gitlab/data/backups gespeichert. Dieses Backup enthält nicht deine gitlab-secrets.json Konfigurationsdatei. Diese Datei befindet sich im Verzeichnis /srv/gitlab/config. Deshalb musst du diese Datei separat sichern. Es gibt eine weitere Konfigurationsdatei, gitlab.rb, die alle Einstellungen für die Gitlab-Instanz enthält. In unserem Fall haben wir jedoch die Variable GITLAB_OMNIBUS_CONFIG in unserer Compose-Datei verwendet, daher wird diese Datei von Gitlab nicht verwendet. Um Änderungen in Gitlab vorzunehmen, musst du sie über die Variable definieren. Daher musst du auch ein Backup der Compose-Datei erstellen.

Du kannst einen Cron-Eintrag erstellen, um deine Gitlab-Installation regelmäßig zu sichern.

Schritt 11 – Gitlab wiederherstellen

Um Gitlab wiederherzustellen, solltest du eine funktionierende Gitlab-Installation auf einem anderen System haben. Außerdem musst du dein Konfigurationsverzeichnis kopieren und die Konfiguration der bestehenden Installation überschreiben.

Um Gitlab wiederherzustellen, musst du mehrere Befehle ausführen. Zuerst musst du die Prozesse stoppen, die mit der Datenbank verbunden sind.

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

Ersetze <name of container> durch den Namen des Containers auf deinem neuen Server.

Vergewissere dich, dass die Prozesse gestoppt sind, bevor du fortfährst.

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

Kopiere die Sicherungsdatei in das Verzeichnis /srv/gitlab/data/backups. Erstelle das Verzeichnis, wenn es nicht existiert.

Führe den Befehl restore aus. Du musst den Teil _gitlab_backup.tar des Dateinamens aus dem Befehl entfernen.

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

Kopiere die Datei gitlab-secrets.json und überschreibe die vorhandene Kopie im Verzeichnis /srv/gitlab/config des neuen Servers. Kopiere außerdem alle Gitlab-Einstellungen aus der gesicherten Compose-Datei in die Datei auf dem neuen Container.

Starte den Gitlab-Container neu. Wir können den Befehl docker compose restart nicht direkt verwenden, da er die Änderungen an der Compose-Datei, die wir benötigen, nicht übernimmt.

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

Überprüfe Gitlab.

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

Schritt 12 – Upgrade von Gitlab

Um Gitlab zu aktualisieren, musst du zunächst ein Backup erstellen, wie im vorherigen Schritt beschrieben.

Als Nächstes wechselst du in das Docker-Compose-Verzeichnis von Gitlab.

$ cd ~/gitlab-docker

Als Nächstes stoppst du den bestehenden Container und entfernst ihn. Deine Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Ziehe die neueste Version des Gitlab-Docker-Images.

$ docker compose pull

Starte die Container erneut.

$ docker compose up -d

Dieses Verfahren ist für das Upgrade zwischen kleineren Versionen von Gitlab geeignet, aber wenn du auf eine Hauptversion umsteigst, musst du zusätzliche Schritte befolgen und Vorsichtsmaßnahmen treffen. Bevor du das Upgrade durchführst, solltest du dir die Dokumentation von Gitlab ansehen.

Fazit

Damit hast du gelernt, wie du Gitlab mit Docker auf einem Ubuntu 22.04 Server installierst. Außerdem hast du dein erstes Projekt erstellt und eine Datei von deinem PC aus in das Projekt übertragen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.