So installierst du Gitlab auf Rocky Linux 9
GitLab Server ist eine Open-Source-Version der in der Cloud gehosteten Versionskontrolle GitLab, die zum Hosten von Git-Repositories verwendet wird. Der Vorteil des Selbsthostings deiner Repositorys gegenüber dem Cloud-Hosting ist die vollständige Kontrolle über deinen Code. GitLab verfügt über alle Funktionen des Cloud-Dienstes und ist damit ein nützliches Werkzeug für dein Entwicklungsteam. Außerdem wird es mit dem Mattermost-Chatdienst ausgeliefert, mit dem deine Nutzer miteinander sprechen und Code-Reviews austauschen können.
In dieser Anleitung lernst du, wie du GitLab Server mit Docker auf einem Ubuntu 22.04 Server installierst. GitLab bietet zwei Editionen an – die kostenlose Community Edition und die kostenpflichtige Enterprise Edition. Wir werden die Community-Edition installieren. Du kannst sie auf die Enterprise Edition upgraden, wenn du mehr Funktionen haben möchtest.
Voraussetzungen
- Ein Server mit Rocky Linux 9 mit mindestens 4 GB RAM und 4 CPU-Kernen, der bis zu 500 Benutzer unterstützt.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Domain-Name, der auf den Server verweist:
gitlab.example.com. Je nach Bedarf werden wir auchmattermost.example.comundpages.example.comverwenden. - Alles ist auf dem neuesten Stand.
$ sudo dnf update
- Ein paar Pakete, die dein System braucht.
$ sudo dnf install -y wget nano unzip yum-utils policycoreutils-python-utils
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du zunächst die Firewall so konfigurieren, dass sie die Ports für HTTP und HTTPS öffnet. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --zone=public --list-all
Es sollte die folgende Ausgabe angezeigt werden.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Öffne die HTTP- und HTTPS-Ports in der Firewall.
$ sudo firewall-cmd --zone=public --add-service=http $ sudo firewall-cmd --zone=public --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --zone=public --list-all
Du solltest eine ähnliche Ausgabe sehen.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client http https ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Setze alle Änderungen dauerhaft um und lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --runtime-to-permanent $ sudo firewall-cmd --reload
Schritt 2 – Installiere die Abhängigkeiten
Bevor du GitLab installierst, ist es wichtig, die Pakete zu installieren, die GitLab benötigt, um richtig zu funktionieren. Alle diese Pakete sind im Rocky Linux Repository verfügbar.
Gib den folgenden Befehl ein, um die Abhängigkeiten zu installieren.
$ sudo dnf install -y curl policycoreutils openssh-server perl
GitLab benötigt eine funktionierende E-Mail-Lösung, um Benachrichtigungs-E-Mails zu versenden. Hierfür gibt es zwei Möglichkeiten. Eine davon ist, Postfix zu installieren. Die zweite Möglichkeit ist die Verwendung eines externen SMTP-Dienstes. Wenn du dich für Postfix entscheidest, installierst du es mit dem unten stehenden Befehl.
$ sudo dnf install postfix
Während der Installation wirst du eventuell nach der Art der Website gefragt. Wähle die Option Internet-Site, um fortzufahren, füge den FQDN deines Servers für mail name hinzu und drücke die Eingabetaste, um fortzufahren. Wenn du weitere Bildschirme siehst, drücke weiterhin die Eingabetaste, um die Standardoptionen auszuwählen.
Du brauchst noch viel mehr, um Postfix als SMTP-Server zu konfigurieren, und die Anleitung dazu würde den Rahmen dieses Artikels sprengen. GitLab hat einen Artikel über die Konfiguration von Postfix, den du dir ansehen kannst.
Schritt 3 – GitLab installieren
Lade das Skript zur Installation des GitLab-Repositorys herunter und führe es aus.
$ curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.rpm.sh | sudo bash
Ignoriere die Warnung über das fehlende Paket pygpgme, da es unter Rocky Linux 9 nicht verfügbar ist.
GitLab wird mit vielen Paketen ausgeliefert, was die Verwaltung sehr erleichtert. GitLab wird zum Beispiel mit dem Webserver Nginx und der Unterstützung für die Erstellung von Let’s Encrypt SSL-Zertifikaten ausgeliefert.
Wenn du bei der Installation eine externe URL für deine GitLab-Website angibst, wird diese automatisch konfiguriert und SSL-Zertifikate werden erstellt und angewendet. Du kannst während der Installation auch ein Administratorkennwort angeben. Wenn du das nicht tust, generiert GitLab ein temporäres Passwort, das nach einem Tag automatisch gelöscht wird.
Wir werden sowohl die externe URL als auch das Administratorkennwort angeben. Führe den folgenden Befehl aus, um GitLab zu installieren.
$ sudo GITLAB_ROOT_PASSWORD="<strongpassword>" EXTERNAL_URL="https://gitlab.example.com" dnf install -y gitlab-ee
Wähle ein sicheres Passwort für deine Installation. Hier installieren wir die GitLab Enterprise Edition (gitlab-ee). Wenn du die Lizenz nicht kaufst und beantragst, funktioniert sie genauso gut wie die kostenlose Community Edition. Wenn du jedoch die Community Edition (gitlab-ce) installierst, musst du für ein Upgrade erneut die Enterprise Edition installieren. Deshalb empfehlen wir dir, die Enterprise Edition zu installieren, auch wenn du kein Upgrade durchführen möchtest.
Sobald die Installation abgeschlossen ist, solltest du eine ähnliche Ausgabe erhalten.
Notes:
Default admin account has been configured with following details:
Username: root
Password: You didn't opt-in to print initial root password to STDOUT.
NOTE: Because these credentials might be present in your log files in plain text, it is highly recommended to reset the password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.
gitlab Reconfigured!
*. *.
*** ***
***** *****
.****** *******
******** ********
,,,,,,,,,***********,,,,,,,,,
,,,,,,,,,,,*********,,,,,,,,,,,
.,,,,,,,,,,,*******,,,,,,,,,,,,
,,,,,,,,,*****,,,,,,,,,.
,,,,,,,****,,,,,,
.,,,***,,,,
,*,.
_______ __ __ __
/ ____(_) /_/ / ____ _/ /_
/ / __/ / __/ / / __ `/ __ \
/ /_/ / / /_/ /___/ /_/ / /_/ /
\____/_/\__/_____/\__,_/_.___/
Thank you for installing GitLab!
GitLab should be available at https://gitlab.example.com
For a comprehensive list of configuration options please see the Omnibus GitLab readme
https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/README.md
Help us improve the installation experience, let us know how we did with a 1 minute survey:
https://gitlab.fra1.qualtrics.com/jfe/form/SV_6kVqZANThUQ1bZb?installation=omnibus&release=16-9
Verifying : gitlab-ee-16.9.1-ee.0.el9.x86_64 1/1
Installed:
gitlab-ee-16.9.1-ee.0.el9.x86_64
Complete!
Du kannst auch eine bestimmte Version von GitLab installieren. Schau zuerst in der Liste der verfügbaren GitLab-Versionen nach.
$ sudo dnf --showduplicates list gitlab-ee*
Du solltest eine ähnliche Ausgabe erhalten.
Available Packages gitlab-ee.x86_64 16.0.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.7-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.0.8-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.1.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.7-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.8-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.2.9-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.3.7-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.4.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.7-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.5.8-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.6.7-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.4-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.5-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.7.6-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.8.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.8.1-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.8.2-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.8.3-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.9.0-ee.0.el9 gitlab_gitlab-ee gitlab-ee.x86_64 16.9.1-ee.0.el9 gitlab_gitlab-ee
Lass uns die Version 16.7.0 installieren.
$ sudo GITLAB_ROOT_PASSWORD="<strongpassword>" EXTERNAL_URL="https://gitlab.example.com" dnf install -y gitlab-ee-16.7.0-ee.0.el9
Überprüfe den Status von GitLab und den zugehörigen Diensten.
$ sudo gitlab-ctl status
Du solltest die folgende Ausgabe sehen.
run: alertmanager: (pid 6551) 1013s; run: log: (pid 6306) 1093s run: crond: (pid 6507) 1018s; run: log: (pid 5663) 1251s run: gitaly: (pid 6479) 1020s; run: log: (pid 5297) 1419s run: gitlab-exporter: (pid 6522) 1016s; run: log: (pid 6183) 1118s run: gitlab-kas: (pid 5553) 1400s; run: log: (pid 5566) 1399s run: gitlab-workhorse: (pid 6455) 1021s; run: log: (pid 5766) 1233s run: logrotate: (pid 5181) 1434s; run: log: (pid 5189) 1433s run: nginx: (pid 6470) 1021s; run: log: (pid 5806) 1227s run: node-exporter: (pid 6515) 1017s; run: log: (pid 6150) 1124s run: postgres-exporter: (pid 6563) 1013s; run: log: (pid 6351) 1087s run: postgresql: (pid 5360) 1411s; run: log: (pid 5385) 1408s run: prometheus: (pid 6532) 1016s; run: log: (pid 6268) 1100s run: puma: (pid 5666) 1247s; run: log: (pid 5673) 1246s run: redis: (pid 5227) 1428s; run: log: (pid 5236) 1427s run: redis-exporter: (pid 6524) 1016s; run: log: (pid 6233) 1110s run: registry: (pid 6480) 1020s; run: log: (pid 5956) 1165s run: sidekiq: (pid 5692) 1241s; run: log: (pid 5700) 1240s
Du kannst GitLab mit den folgenden Befehlen anhalten und starten.
$ sudo gitlab-ctl stop $ sudo gitlab-ctl start
GitLab sollte jetzt laufen.
Du kannst auch einen einzelnen Dienst mit den folgenden Befehlen stoppen und starten.
$ sudo gitlab-ctl stop nginx $ sudo gitlab-ctl start nginx $ sudo gitlab-ctl restart nginx
Du kannst auf deine GitLab-Installation zugreifen, indem du https://gitlab.example.com im Browser aufrufst. Wir werden in späteren Schritten auf die Konfiguration von GitLab zurückkommen.
Schritt 4 – SSL konfigurieren
GitLab speichert seine Konfiguration in der Datei /etc/gitlab/gitlab.rb. Öffne sie zum Bearbeiten.
$ sudo nano /etc/gitlab/gitlab.rb
Finde den Abschnitt Let's Encrypt Integration und ändere die Werte wie unten gezeigt.
letsencrypt['contact_emails'] = ['name@example.com'] # This should be an array of email addresses to add as contacts letsencrypt['auto_renew'] = true letsencrypt['auto_renew_hour'] = "12" letsencrypt['auto_renew_minute'] = "30" letsencrypt['auto_renew_day_of_month'] = "*/7"
Damit aktivierst du Let’s Encrypt, legst die E-Mail für die Benachrichtigung über das Auslaufen von SSL fest und stellst ein, dass die Zertifikate automatisch an jedem siebten Tag des Monats um 12:30 Uhr Serverzeit erneuert werden.
Aktiviere die DHParam-Richtlinie
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/gitlab/ssl/dhparams.pem 4096
Setze die folgende Option in der Datei.
nginx['ssl_dhparam'] = "/etc/gitlab/ssl/dhparams.pem" # Path to dhparams.pem, eg. /etc/gitlab/ssl/dhparams.pem
HTTP Strict Transport Security (HSTS) deaktivieren
Wenn du HTTPS aktivierst, wird automatisch der HSTS-Dienst aktiviert. Manchmal kann das zu Problemen führen, wenn du es später nicht brauchst. Um HSTS zu deaktivieren, konfiguriere die folgenden Variablen.
nginx['hsts_include_subdomains'] = false
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Konfiguriere GitLab mit den neuen Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Dieser Vorgang kann einige Zeit in Anspruch nehmen. Sobald er abgeschlossen ist, kannst du auf deine GitLab-Installation zugreifen, indem du https://gitlab.example.com im Browser aufrufst. Du solltest die folgende Anmeldeseite sehen.
Schritt 5 – SMTP konfigurieren
GitLab muss Benachrichtigungs-E-Mails verschicken und dafür müssen wir die SMTP-Einstellungen aktivieren. Wenn du Postfix verwendest, kannst du diesen Schritt auslassen. Andernfalls lass uns fortfahren.
Öffne die GitLab-Konfigurationsdatei, um sie zu bearbeiten.
$ sudo nano /etc/gitlab/gitlab.rb
Wir werden Amazon SES für unser Tutorial verwenden. Suche den Abschnitt SMTP in der Datei und stelle die Werte wie unten gezeigt ein.
gitlab_rails['smtp_enable'] = true gitlab_rails['smtp_address'] = "email-smtp.region-1.amazonaws.com" gitlab_rails['smtp_port'] = 587 gitlab_rails['smtp_user_name'] = "IAMmailerKey" gitlab_rails['smtp_password'] = "IAMmailerSecret" gitlab_rails['smtp_domain'] = "example.com" gitlab_rails['smtp_authentication'] = "login" gitlab_rails['smtp_enable_starttls_auto'] = true # If your SMTP server does not like the default 'From: gitlab@localhost' you # can change the 'From' with this setting. gitlab_rails['gitlab_email_from'] = 'gitlab@example.com' gitlab_rails['gitlab_email_display_name'] = 'Howtoforge GitLab' gitlab_rails['gitlab_email_reply_to'] = 'noreply@example.com'
Du kannst SMTP-Verbindungspooling aktivieren, indem du die folgende Option einstellst.
gitlab_rails['smtp_pool'] = true
Dadurch können Sidekiq-Arbeiter SMTP-Verbindungen für mehrere Aufträge wiederverwenden.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Du kannst auch die SMTP-Authentifizierungsdaten verschlüsseln. Führe den folgenden Befehl aus.
sudo gitlab-rake gitlab:smtp:secret:edit EDITOR=nano
Gib den SMTP-Benutzernamen und das Passwort wie gezeigt in die Datei ein.
user_name: 'smtp user' password: 'smtp password'
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Entferne die Variablen gitlab_rails['smtp_user_name'], and gitlab_rails['smtp_password'] aus der /etc/gitlab/gitlab.rb.
Sobald du die SMTP-Einstellungen abgeschlossen hast, konfiguriere die GitLab-Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Schritt 6 – Nginx konfigurieren
Der in GitLab integrierte Nginx-Server kann umfangreich konfiguriert werden. Wir gehen einige der wichtigen Optionen durch.
Öffne die GitLab-Konfigurationsdatei zum Bearbeiten.
$ sudo nano /etc/gitlab/gitlab.rb
Leite HTTP zu HTTPS um.
Ändere die folgenden Werte, um HTTP- zu HTTPS-Links automatisch umzuleiten.
nginx['redirect_http_to_https'] = true
Einstellen des Referrer-Policy-Headers
Standardmäßig setzt GitLab den Referrer-Policy Header bei allen Antworten auf strict-origin-when-cross-origin. Konfiguriere die folgende Variable, um diesen Header auf einen anderen Wert zu setzen.
nginx['referrer_policy'] = 'same-origin'
Benutzerdefinierte Nginx-Einstellungen in den GitLab-Serverblock einfügen
Verwende die folgende Variable, um benutzerdefinierte Einstellungen in den GitLab-Serverblock einzufügen.
# Example: block raw file downloads from a specific repository
nginx['custom_gitlab_server_config'] = "location ^~ /foo-namespace/bar-project/raw/ {\n deny all;\n}\n"
Benutzerdefinierte Einstellungen in die Nginx-Konfiguration einfügen
Verwende die folgende Einstellung, um benutzerdefinierte Einstellungen einzufügen.
# Example: include a directory to scan for additional config files nginx['custom_nginx_config'] = "include /etc/gitlab/nginx/sites-enabled/*.conf;"
Erstelle das Verzeichnis /etc/gitlab/nginx/sites-available.
$ sudo mkdir /etc/gitlab/nginx/sites-available
Erstelle die Blockdatei in diesem Verzeichnis.
$ sudo touch /etc/gitlab/nginx/sites-enabled/example.conf
Bearbeite sie und füge deine Einstellungen hinzu.
$ sudo nano /etc/gitlab/nginx/sites-enabled/example.conf
Wenn du fertig bist, gehe zurück zum Terminal und führe den folgenden Befehl aus, um das Verzeichnis /etc/gitlab/nginx/sites-enabled zu erstellen.
$ sudo mkdir /etc/gitlab/nginx/sites-enabled
Führe den folgenden Befehl aus, um einen Symlink zu erstellen.
sudo ln -s /etc/gitlab/nginx/sites-available/example.conf /etc/gitlab/nginx/sites-enabled/example.conf
Wenn du mit der Konfiguration von Nginx fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Konfiguriere die GitLab-Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Schritt 7 – Aktiviere die Container-Registry
Die Container-Registry wird automatisch aktiviert und ist auf deiner GitLab-Domäne verfügbar, und zwar an Port 5050, wenn du die integrierte Let’s Encrypt-Integration verwendest.
Öffne die Konfigurationsdatei von GitLab.
$ sudo nano /etc/gitlab/gitlab.rb
Lege die externe URL für deine GitLab-Container-Registry fest.
registry_external_url 'https://gitlab.example.com:5050'
Lege die HTTP-zu-HTTPS-Umleitung fest, indem du die folgende Zeile unter der obigen Zeile einfügst.
registry_nginx['redirect_http_to_https'] = true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Konfiguriere die GitLab-Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Öffne Port 2425 in der Firewall.
$ sudo firewall-cmd --zone=public --add-port=5050/tcp $ sudo firewall-cmd --runtime-to-permanent $ sudo firewall-cmd --reload
Überprüfe mit dem folgenden Befehl.
$ openssl s_client -showcerts -servername gitlab.example.com -connect gitlab.example.com:5050 > cacert.pem
Mit dem folgenden Befehl solltest du dich mit deinen GitLab-Zugangsdaten bei der Container-Registry von Docker anmelden können.
$ docker login gitlab.example.com:5050
Du kannst auch eine andere URL wie https://registry.gitlab.example.com für deine Container-Registry verwenden, was eine zusätzliche Konfiguration erfordert. Du kannst auch S3-Speicher für die Container konfigurieren. Die Anleitung dazu findest du in der GitLab Container Registry Dokumentation.
Schritt 8 – GitLab-Seiten einrichten
Du brauchst eine Domain, die keine Subdomain der GitLab-URL ist. Für unsere Zwecke werden wir https://pages.example.com verwenden, um GitLab-Seiten zu hosten. Wir gehen außerdem davon aus, dass wir keine Wildcard DNS verwenden.
Öffne die Konfigurationsdatei von GitLab.
$ sudo nano /etc/gitlab/gitlab.rb
Setze die folgenden Variablen wie gezeigt.
pages_external_url 'https://pages.example.com' ..... # Experimental - Enable namespace in path gitlab_pages["namespace_in_path"] = true
Konfiguriere Nginx für GitLab-Seiten im Abschnitt GitLab Pages NGINX.
# Below you can find settings that are exclusive to "GitLab Pages NGINX" pages_nginx['enable'] = true pages_nginx['redirect_http_to_https'] = true pages_nginx['ssl_certificate'] = "/etc/letsencrypt/live/pages.example.com/fullchain.pem" pages_nginx['ssl_certificate_key'] = "/etc/letsencrypt/live/pages.example.com/privkey.pem"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Konfiguriere die GitLab-Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Wenn du eine DNS-basierte Wildcard-Domain hosten willst, schau in der GitLab Pages-Dokumentation nach.
Schritt 9 – Aktiviere MatterMost
Mattermost ist ein Open-Source-Online-Chatdienst mit Funktionen wie Dateifreigabe, Emojis, GIFs, Markdown-Unterstützung, Syntaxhervorhebung und Unterstützung mehrerer Sprachen. GitLab wird mit Mattermost ausgeliefert, das du aktivieren kannst, damit die Nutzer/innen des Unternehmens, die sich die GitLab-Instanz teilen, miteinander kommunizieren können.
GitLab Mattermost ist standardmäßig deaktiviert. Um es zu aktivieren, öffne die GitLab-Konfigurationsdatei.
$ sudo nano /etc/gitlab/gitlab.rb
Füge die externe URL von Mattermost hinzu. GitLab generiert automatisch die SSL-Verschlüsselung für die URL mit Let’s Encrypt.
mattermost_external_url 'https://mattermost.example.com'
Stelle sicher, dass die HTTP-zu-HTTPS-Konfigurationseinstellung für Mattermost auf true gesetzt ist, indem du die folgende Zeile hinzufügst.
mattermost_nginx['redirect_http_to_https'] = true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Konfiguriere die GitLab-Einstellungen neu.
$ sudo gitlab-ctl reconfigure
Du solltest nun in der Lage sein, über https://mattermost.example.com auf Mattermost zuzugreifen. Wenn du die URL aufrufst, solltest du die folgende Seite sehen.
Wenn du die Mattermost-App installiert hast, wähle die Schaltfläche In Desktop-App anzeigen oder wähle die Option In Browser anzeigen. Achte darauf, dass du die Option Meine Einstellung merken ankreuzt, damit du nicht noch einmal gefragt wirst. Wir werden im nächsten Schritt auf die Konfiguration von Mattermost zurückkommen.
SMTP für Mattermost konfigurieren
Mattermost speichert seine Konfiguration in der Datei /var/opt/gitlab/mattermost/config.json. Öffne sie zum Bearbeiten.
$ sudo nano /var/opt/gitlab/mattermost/config.json
Suche den Abschnitt "EmailSettings" und konfiguriere ihn wie gezeigt. Die Felder FeedbackEmail, ReplyToAddress, EnableSMTPAuth, SMTPUsername, SMTPPassword, SMTPServer, SMTPPort, ConnectionSecurity und SkipServerCertificateVerification müssen wir einstellen, damit es funktioniert.
"EmailSettings": {
"EnableSignUpWithEmail": true,
"EnableSignInWithEmail": true,
"EnableSignInWithUsername": true,
"SendEmailNotifications": true,
"UseChannelInEmailNotifications": false,
"RequireEmailVerification": false,
"FeedbackName": "Howtoforge Mattermost",
"FeedbackEmail": "name@example.com",
"ReplyToAddress": "noreply@example.com",
"FeedbackOrganization": "",
"EnableSMTPAuth": true,
"SMTPUsername": "AmazonSESUsername",
"SMTPPassword": "AmazonSESPassword",
"SMTPServer": "email-smtp.us-west-2.amazonaws.com",
"SMTPPort": "465",
"SMTPServerTimeout": 10,
"ConnectionSecurity": "TLS",
"SendPushNotifications": true,
"PushNotificationServer": "https://push-test.mattermost.com",
"PushNotificationContents": "full",
"PushNotificationBuffer": 1000,
"EnableEmailBatching": false,
"EmailBatchingBufferSize": 256,
"EmailBatchingInterval": 30,
"EnablePreviewModeBanner": false,
"SkipServerCertificateVerification": true,
"EmailNotificationContentsType": "full",
"LoginButtonColor": "#0000",
"LoginButtonBorderColor": "#2389D7",
"LoginButtonTextColor": "#2389D7"
},
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 10 – GitLab Web aufrufen und konfigurieren
Auf GitLab zugreifen
Ö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 in deinem GitLab-Dashboard anzumelden. Nachdem du dich angemeldet hast, wird der folgende Dashboard-Bildschirm angezeigt.
Wie du siehst, hat GitLab bereits ein Projekt zur Überwachung der Instanz erstellt.
GitLab für Wartungsarbeiten herunterfahren
Wenn du deine GitLab-Instanz in den Wartungszustand versetzen möchtest, während du Serveraufgaben durchführst, verwende den folgenden Befehl.
$ sudo gitlab-ctl deploy-page up cp /opt/gitlab/embedded/service/gitlab-rails/public/deploy.html /opt/gitlab/embedded/service/gitlab-rails/public/index.html
Wenn ein Benutzer die GitLab-Website besucht, wird er die Seite Deploy in progress sehen.
Um die Seite zu entfernen, führst du den folgenden Befehl aus.
$ sudo gitlab-ctl deploy-page down
Wenn du die Projekte schreibgeschützt machen willst, führe den folgenden Befehl aus, um eine Rails-Konsole zu öffnen.
$ sudo gitlab-rails console
Sie sieht wie die folgende aus.
-------------------------------------------------------------------------------- Ruby: ruby 3.1.4p223 (2023-03-30 revision 957bb7cb81) [x86_64-linux] GitLab: 16.9.2-ee (0d71d32d321) EE GitLab Shell: 14.33.0 PostgreSQL: 14.10 ------------------------------------------------------------[ booted in 78.60s ] Loading production environment (Rails 7.0.8) irb(main):001:0>
Setze alle Projekte mit dem folgenden Befehl auf schreibgeschützt.
Project.all.find_each { |project| project.update!(repository_read_only: true) }
Beende die Konsole, indem du exit eingibst. Um die Projekte wieder in den normalen Zustand zu versetzen, verwende den folgenden Befehl in der Konsole.
Project.all.find_each { |project| project.update!(repository_read_only: false) }
Öffentliche Anmeldungen einschränken
In der Standardeinstellung kann jeder ein Konto erstellen und Zugang erhalten. Wenn du das nicht möchtest, kannst du es abschalten. 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 in deinem Dashboard nicht siehst, kannst du die Einstellungsseite aufrufen, indem du unten links im Menü auf die Schaltfläche Adminbereich klickst.
Im Verwaltungsbereich fährst du mit der Maus über die Option Einstellungen in der linken Seitenleiste und klickst auf das Untermenü Allgemein. Von dort aus gelangst du zum Bereich Anmeldebeschränkungen.
GitLab-Profil konfigurieren
Dein Standardprofil ist ziemlich langweilig und hat nichts zu bieten. Um das zu ändern, klickst du auf das Benutzersymbol in der oberen linken Ecke, um das Dropdown-Menü aufzurufen, und wählst 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. Bei früheren Versionen von GitLab musstest du 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.
Den Benutzernamen ändern und die Zwei-Faktor-Authentifizierung aktivieren
Du kannst deinen Standardbenutzernamen für 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 solltest. 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 Datenschutz legst und dies nicht möchtest, erweitere die Option Nutzungsstatistiken auf derselben Seite und deaktiviere die Option Service Ping aktivieren. Klicke auf die Schaltfläche Änderungen speichern, um die Änderung zu übernehmen.
Mattermost konfigurieren
Öffne die URL https://mattermost.example.com und du wirst auf die folgende Anmeldeseite weitergeleitet.
Klicke auf die Schaltfläche GitLab, um dich anzumelden. Dadurch wird dein Mattermost-Konto mit deinem GitLab-Konto verbunden. Du wirst zur GitLab-Anmeldeseite weitergeleitet, wo du deine Anmeldedaten eingibst und auf die Schaltfläche Anmelden klickst, um fortzufahren. Du wirst auf die unten abgebildete Autorisierungsseite weitergeleitet.
Klicke auf die Schaltfläche Autorisieren, um fortzufahren. Du kehrst zur Mattermost-Anwendung zurück und wirst nach dem Namen deiner Organisation gefragt.
Gib den Namen deiner Organisation ein und klicke auf die Seite Weiter. Als nächstes wirst du gefragt, welche Tools du bei deiner Arbeit verwendest.
Klicke auf das GitLab-Symbol und dann auf die Schaltfläche Weiter, um fortzufahren. Du kannst später jederzeit weitere Tools hinzufügen. Als Nächstes wirst du aufgefordert, deine Teammitglieder einzuladen und erhältst einen Einladungslink.
Speichere den Link für später und klicke auf Setup beenden, um die Installation von Mattermost abzuschließen. Du wirst zum Mattermost-Dashboard weitergeleitet, von wo aus du es nutzen kannst.
GitLab darf nur für die Anmeldung bei der Mattermost-Instanz verwendet werden. Auf der Mattermost-Instanz ist ein GitLab-Plugin vorinstalliert, das Commits und Benachrichtigungen von deinem Repository an deine Mattermost-Instanz senden kann. Auch das müssen wir konfigurieren.
Besuche die Seite GitLab >> Profil bearbeiten und wähle das Menü Anwendungen in der linken Seitenleiste. Du solltest sehen, dass deine bestehende Mattermost-Anmeldeanwendung bereits registriert ist.
Klicke auf die Schaltfläche Neue Anwendung hinzufügen, um eine weitere Anwendung für das GitLab-Plugin zu erstellen.
Gib dem Projekt einen Namen. Lege https://mattermost.example.com/plugins/com.github.manland.mattermost-plugin-gitlab/oauth/complete als Redirect URI fest. Aktiviere die Optionen Confidential, api und read_user. Klicke unten auf der Seite auf die Schaltfläche Anwendung speichern, um den Vorgang abzuschließen.
Du wirst auf die folgende Seite weitergeleitet. Kopiere und speichere die Anwendungs-ID und das Anwendungsgeheimnis, die du später benötigst. Das Bewerbungsgeheimnis wird nur einmal angezeigt, also achte darauf.
Klicke auf die Schaltfläche Weiter, um den Vorgang abzuschließen.
Öffne deine Mattermost-Website und klicke auf die Schaltfläche ganz oben links, um das folgende Popup-Menü aufzurufen.
Klicke auf die Schaltfläche App Marketplace, um das folgende Popup-Fenster zu öffnen.
Klicke auf die Schaltfläche Configure (Konfigurieren) neben dem GitLab-Plugin, um fortzufahren.
Gib die GitLab-URL, die OAuth-Client-ID und das zuvor generierte OAuth-Client-Geheimnis ein und klicke zum Abschluss auf die Schaltfläche Speichern.
Jetzt muss jeder Nutzer sein GitLab-Konto in Mattermost verbinden. Besuche den GitLab-Kanal auf Mattermost und gib den folgenden Befehl ein, um /gitlab connect zu starten und drücke die Eingabetaste.
Klicke auf die Schaltfläche Verbinden und du wirst auf eine neue Seite weitergeleitet, auf der du die Verbindung autorisieren musst. Wenn du auf Verbinden klickst, kommst du zurück zur Mattermost-Seite und solltest die folgende Meldung sehen, die die Verbindung bestätigt.
Schritt 11 – 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 über das 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 zu
$ 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 AAAAC3NzaC1lZDI1NTE5AAAAIGCEIN84O/9tcvE5wsTswY76xeJyY7TwkMW6uCvYulm1 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 vorgesehene Feld ein und klicke auf Schlüssel hinzufügen, um fortzufahren. Du bekommst ein Standardablaufdatum angezeigt. Du kannst es nach deinen Bedürfnissen ändern.
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. Als Nächstes erhältst du eine Erfolgsmeldung, die deine Verbindung zu deiner GitLab-Instanz bestätigt.
The authenticity of host 'gitlab.example.com (178.62.213.105)' can't be established. ECDSA key fingerprint is SHA256:x1647s5G1iL/cnRFoBuE6qzRZF775fVLZzcLJTGaIvQ. Are you sure you want to continue connecting (yes/no/[fingerprint])? yes Warning: Permanently added 'gitlab.example.com,178.62.213.105' (ECDSA) to the list of known hosts. 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. Ein Projekt umfasst ein Repository, einen Issue Tracker, Merge Requests, ein Wiki, Continuous Integration, Continuous Delivery (CI/CD) Pipelines und viele andere Funktionen.
Um dein erstes Repository zu erstellen, klicke auf deiner Homepage auf den Abschnitt Projekt erstellen.
Du wirst auf die Seite Neues Projekt weitergeleitet, auf der du mehrere Optionen für die Erstellung eines neuen Projekts findest.
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ü in der Option Projekt-URL im Feld Wähle eine Gruppe oder einen Namensraum. Lege deinen Projekt-Slug fest, wenn du den Standard-Slug ändern möchtest. Ändere die Sichtbarkeitsstufe des Projekts nach deinem Bedarf. Du kannst dein Repository mit einer README Datei initialisieren. Wenn du möchtest, dass GitLab deinen Code auf Sicherheitsschwachstellen analysiert, aktiviere die Option SAST aktivieren.
Wenn du fertig bist, klicke zum Abschluss auf Projekt erstellen. Du gelangst zu deiner Repository-Seite mit einer einzigen leeren README.md Datei.
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
Du solltest eine ähnliche Ausgabe sehen.
Cloning into 'howtoforge-test'... Enter passphrase for key '/c/Users/navjo/.ssh/id_ed25519': remote: Enumerating objects: 3, done. remote: Counting objects: 100% (3/3), done. remote: Compressing objects: 100% (2/2), done. remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 Receiving objects: 100% (3/3), done.
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" [main d6c7a9c] add Changelog 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 CHANGELOG $ git push -u origin main Enter passphrase for key '/c/Users/navjo/.ssh/id_ed25519': Enumerating objects: 4, done. Counting objects: 100% (4/4), done. Delta compression using up to 4 threads Compressing objects: 100% (2/2), done. Writing objects: 100% (3/3), 958 bytes | 958.00 KiB/s, done. Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 To gitlab.example.com:navjot/howtoforge-test.git 523db9a..d6c7a9c main -> main branch 'main' set up to track '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.
Das war’s mit unserem ersten GitLab-Projekt.
Schritt 12 – GitLab sichern
GitLab bietet eine Befehlszeilenschnittstelle, mit der du deine gesamte Instanz sichern kannst, einschließlich der Datenbank, der Anhänge, der Repository-Daten, der CI/CD-Job-Artefakte, der CI/CD-Job-Ausgabeprotokolle, der LFS-Objekte, der Terraform-Status, der Container-Registry-Images, der Inhalte der GitLab-Seiten, der Pakete, der Snippets, der Gruppen-Wikis, der Merge-Request-Diffs und der sicheren Dateien auf Projektebene.
Mattermost-Daten, Redis-Daten, Sidekiq-Aufträge und Objektspeicher werden nicht mitgesichert.
Führe den folgenden Befehl aus, um die Sicherung durchzuführen.
$ sudo gitlab-backup create STRATEGY=copy
Die Option STRATEGY=copy dient dazu, Fehler zu vermeiden, falls sich die Daten schnell ändern. Dadurch werden die Daten an einen temporären Ort kopiert und mögliche Fehler vermieden.
Du solltest eine ähnliche Ausgabe sehen.
2024-03-07 11:48:37 UTC -- Dumping database ...
Dumping PostgreSQL database gitlabhq_production ... [DONE]
2024-03-07 11:48:45 UTC -- Dumping database ... done
2024-03-07 11:48:45 UTC -- Dumping repositories ...
{"command":"create","gl_project_path":"navjot/howtoforge-test","level":"info","msg":"started create","pid":107325,"relative_path":"@hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.git","storage_name":"default","time":"2024-03-07T11:48:45.720Z"}
{"command":"create","gl_project_path":"navjot/howtoforge-test","level":"info","msg":"completed create","pid":107325,"relative_path":"@hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.git","storage_name":"default","time":"2024-03-07T11:48:45.772Z"}
{"command":"create","gl_project_path":"navjot/howtoforge-test.wiki","level":"info","msg":"started create","pid":107325,"relative_path":"@hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.wiki.git","storage_name":"default","time":"2024-03-07T11:48:45.874Z"}
{"command":"create","gl_project_path":"navjot/howtoforge-test.wiki","level":"info","msg":"completed create","pid":107325,"relative_path":"@hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.wiki.git","storage_name":"default","time":"2024-03-07T11:48:45.894Z"}
2024-03-07 11:48:45 UTC -- Dumping repositories ... done
2024-03-07 11:48:45 UTC -- Dumping uploads ...
2024-03-07 11:48:46 UTC -- Dumping uploads ... done
2024-03-07 11:48:46 UTC -- Dumping builds ...
2024-03-07 11:48:46 UTC -- Dumping builds ... done
2024-03-07 11:48:46 UTC -- Dumping artifacts ...
2024-03-07 11:48:46 UTC -- Dumping artifacts ... done
2024-03-07 11:48:46 UTC -- Dumping pages ...
2024-03-07 11:48:46 UTC -- Dumping pages ... done
2024-03-07 11:48:46 UTC -- Dumping lfs objects ...
2024-03-07 11:48:46 UTC -- Dumping lfs objects ... done
2024-03-07 11:48:46 UTC -- Dumping terraform states ...
2024-03-07 11:48:46 UTC -- Dumping terraform states ... done
2024-03-07 11:48:46 UTC -- Dumping container registry images ...
2024-03-07 11:48:46 UTC -- Dumping container registry images ... done
2024-03-07 11:48:46 UTC -- Dumping packages ...
2024-03-07 11:48:46 UTC -- Dumping packages ... done
2024-03-07 11:48:46 UTC -- Dumping ci secure files ...
2024-03-07 11:48:46 UTC -- Dumping ci secure files ... done
2024-03-07 11:48:46 UTC -- Creating backup archive: 1709812117_2024_03_07_16.9.1-ee_gitlab_backup.tar ...
2024-03-07 11:48:46 UTC -- Creating backup archive: 1709812117_2024_03_07_16.9.1-ee_gitlab_backup.tar ... done
2024-03-07 11:48:46 UTC -- Uploading backup archive to remote storage ... [SKIPPED]
2024-03-07 11:48:46 UTC -- Deleting old backups ... [SKIPPED]
2024-03-07 11:48:46 UTC -- Deleting tar staging files ...
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/backup_information.yml
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/db
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/repositories
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/uploads.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/builds.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/artifacts.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/pages.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/lfs.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/terraform_state.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/registry.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/packages.tar.gz
2024-03-07 11:48:46 UTC -- Cleaning up /var/opt/gitlab/backups/ci_secure_files.tar.gz
2024-03-07 11:48:46 UTC -- Deleting tar staging files ... done
2024-03-07 11:48:46 UTC -- Deleting backups/tmp ...
2024-03-07 11:48:46 UTC -- Deleting backups/tmp ... done
2024-03-07 11:48:46 UTC -- Warning: Your gitlab.rb and gitlab-secrets.json files contain sensitive data
and are not included in this backup. You will need these files to restore a backup.
Please back them up manually.
2024-03-07 11:48:46 UTC -- Backup 1709812117_2024_03_07_16.9.1-ee is done.
2024-03-07 11:48:46 UTC -- Deleting backup and restore PID file ... done
Deine Sicherungsdatei wird im Verzeichnis /var/opt/gitlab/backups gespeichert.
$ sudo ls /var/opt/gitlab/backups 1709812117_2024_03_07_16.9.1-ee_gitlab_backup.tar
Wie in der Ausgabe erwähnt, sind deine GitLab-Konfiguration und Geheimnisse nicht in der Sicherung enthalten. Kopiere diese Dateien zur Wiederherstellung manuell an einen sicheren Ort.
Kopiere sie.
$ sudo cp /etc/gitlab/gitlab.rb /etc/gitlab/gitlab-secrets.json /var/opt/gitlab/backups
Du kannst cron so konfigurieren, dass täglich Backups erstellt werden.
Öffne die crontab für den Benutzer root.
$ sudo su - $ EDITOR = nano crontab -e
Füge die folgende Zeile hinzu.
0 2 * * * /opt/gitlab/bin/gitlab-backup create CRON=1
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Mit der Option CRON=1 werden alle Ausgaben ausgeblendet, wenn keine Fehler auftreten. Das hilft dabei, den Cron-Spam zu begrenzen. Wenn du jedoch eine Fehlersuche durchführst, ersetze CRON=1 durch --trace, um ein ausführliches Protokoll zu erstellen.
In der offiziellen GitLab-Backup-Dokumentation findest du weitere Optionen und erfährst, wie du sicherstellen kannst, dass deine Backups automatisch in einen S3-kompatiblen Dienst kopiert werden.
Schritt 13 – GitLab wiederherstellen
Bevor du GitLab wiederherstellst, solltest du sicherstellen, dass du die folgenden Voraussetzungen erfüllst.
- Die GitLab-Version und -Edition sollte mit der Version übereinstimmen, von der das Backup erstellt wurde.
- Du hast den Befehl
sudo gitlab-ctl reconfiguremindestens einmal ausgeführt. - GitLab sollte ausgeführt werden.
- Die GitLab-Geheimnisse und die Einstellungen müssen wiederhergestellt werden.
$ sudo cp gitlab.rb gitlab-secrets.json /etc/gitlab
Kopiere die Sicherungsdatei in das Verzeichnis /var/opt/gitlab/backups.
$ sudo cp 1709812117_2024_03_07_16.9.1-ee_gitlab_backup.tar /var/opt/gitlab/backups/
Setze die richtigen Berechtigungen.
$ sudo chown git:git /var/opt/gitlab/backups/1709812117_2024_03_07_16.9.1-ee_gitlab_backup.tar
Beende die Prozesse, die mit der Datenbank verbunden sind. Du kannst den Rest von GitLab wie gewohnt weiterlaufen lassen.
$ sudo gitlab-ctl stop puma $ sudo gitlab-ctl stop sidekiq
Überprüfe die Prozesse.
$ sudo gitlab-ctl status run: alertmanager: (pid 68055) 76797s; run: log: (pid 66127) 78476s run: crond: (pid 68045) 76798s; run: log: (pid 65624) 78566s run: gitaly: (pid 66424) 78414s; run: log: (pid 65273) 78710s run: gitlab-exporter: (pid 66466) 78411s; run: log: (pid 66002) 78497s run: gitlab-kas: (pid 65535) 78691s; run: log: (pid 65547) 78690s run: gitlab-pages: (pid 68003) 76801s; run: log: (pid 67700) 76996s run: gitlab-workhorse: (pid 66392) 78415s; run: log: (pid 65727) 78550s run: logrotate: (pid 106163) 3124s; run: log: (pid 65169) 78724s run: mattermost: (pid 68027) 76799s; run: log: (pid 67820) 76890s run: nginx: (pid 72647) 75588s; run: log: (pid 65781) 78544s run: node-exporter: (pid 66458) 78411s; run: log: (pid 65968) 78505s run: postgres-exporter: (pid 66505) 78407s; run: log: (pid 66162) 78470s run: postgresql: (pid 65341) 78702s; run: log: (pid 65362) 78699s run: prometheus: (pid 66476) 78410s; run: log: (pid 66070) 78483s down: puma: 14s, normally up; run: log: (pid 65649) 78562s run: redis: (pid 65207) 78719s; run: log: (pid 65216) 78718s run: redis-exporter: (pid 66468) 78410s; run: log: (pid 66034) 78490s run: registry: (pid 66414) 78414s; run: log: (pid 65864) 78528s down: sidekiq: 5s, normally up; run: log: (pid 65681) 78554s
Stelle das Backup wieder her. Vergewissere dich, was du tust, denn dabei wird deine Datenbank überschrieben. Du musst im Befehl nicht den vollständigen Dateinamen angeben. Nur den Teil vor dem -ee_gitlab_backup.tar des Dateinamens.
$ sudo gitlab-backup restore BACKUP=1709812117_2024_03_07_16.9.1-ee
Dies sollte deine GitLab-Installation erfolgreich wiederherstellen.
Schritt 14 – Upgrade von GitLab
Erstelle ein Backup, bevor du ein Upgrade von GitLab durchführst. Ein Upgrade von GitLab ist so einfach wie die Ausführung des Befehls sudo dnf update.
$ sudo dnf update
Kleinere Upgrades können auf diese Weise sicher durchgeführt werden.
DigitalOcean Agent 40 kB/s | 3.3 kB 00:00 DigitalOcean Droplet Agent 44 kB/s | 3.3 kB 00:00 gitlab_gitlab-ee 1.4 kB/s | 1.0 kB 00:00 gitlab_gitlab-ee-source 1.2 kB/s | 951 B 00:00 Dependencies resolved. ======================================================================================================================== Package Architecture Version Repository Size ======================================================================================================================== Upgrading: gitlab-ee x86_64 16.9.2-ee.0.el9 gitlab_gitlab-ee 1.1 G Transaction Summary ======================================================================================================================== Upgrade 1 Package Total download size: 1.1 G Is this ok [y/N]: y
Gib y ein und drücke Enter, um das Upgrade zu starten. Bei Hauptversionen solltest du vor dem Upgrade prüfen, ob Änderungen vorgenommen wurden.
Die Website ist während des Upgrades nicht mehr verfügbar oder du erhältst eine Deploy in progress Meldung im Browser.
Sobald du das Upgrade abgeschlossen hast, führe die folgende Überprüfung durch, um sicherzustellen, dass alles richtig funktioniert.
- Überprüfe die allgemeine Konfiguration.
$ sudo gitlab-rake gitlab:check
- Bestätige, dass verschlüsselte Datenbankwerte entschlüsselt werden können.
$ sudo gitlab-rake gitlab:doctor:secrets
- Überprüfe, ob sich die Benutzer anmelden können, ob die Projektliste sichtbar ist, ob auf Projektprobleme und Merge Requests zugegriffen werden kann, ob Benutzer Repositories klonen können und ob sie in der GitLab UI Commits an GitLab senden können.
- Überprüfe für GitLab CI/CD, ob Runner Aufträge abholen können und die Docker-Registry funktioniert.
Fazit
Damit ist unser Tutorium abgeschlossen. Du hast gelernt, wie du GitLab auf einem Rocky Linux 9 Server installierst und konfigurierst. Außerdem hast du dein erstes Projekt erstellt und eine Datei von deinem PC aus in das Projekt übertragen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.