So installierst und konfigurierst du GoCD unter Ubuntu 22.04
GoCD ist ein Open-Source-System für kontinuierliche Bereitstellung und Automatisierung. GoCD eignet sich hervorragend für die Modellierung komplexer CD-Workflows und ermöglicht mit seinen Modellierungskonstrukten, der parallelen Ausführung und dem Abhängigkeitsmanagement schnelles Feedback. GoCD hilft dir bei der Fehlersuche in einer fehlerhaften Pipeline, indem es jede Änderung vom Commit bis zur Bereitstellung in Echtzeit verfolgt. Mit GoCD kannst du ganz einfach zwei Builds vergleichen und jede beliebige Version der Anwendung bereitstellen, die du möchtest. Das GoCD-Ökosystem besteht aus einem GoCD-Server und einem GoCD-Agenten. GoCD steuert alles, z. B. die webbasierte Benutzeroberfläche und die Verwaltung und Bereitstellung von Aufträgen an den Agenten. Die Go-Agenten sind für die Ausführung der Aufträge und den Einsatz verantwortlich.
In diesem Lernprogramm lernst du, wie du GoCD auf einem Ubuntu 22.04 Server installierst und konfigurierst.
Voraussetzungen
- Ein Server mit Ubuntu 22.04 und mindestens 2 GB RAM.
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
- Fully Qualified Domain Names(FQDN), die auf deinen Server zeigen. Wir werden
gocd.example.comfür unser Tutorial verwenden. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du zunächst die Firewall so konfigurieren, dass sie die Ports für HTTP, HTTPS und Synapse öffnet.
Ü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)
Öffne die HTTP-, HTTPS- und GoCD-Ports in der Firewall.
$ sudo ufw allow 8153 $ sudo ufw allow http $ sudo ufw allow https
Überprüfe den Status zur Bestätigung erneut.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 8153 ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 8153 (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – GoCD installieren
Importiere den GPG-Schlüssel von GoCD in dein System.
$ curl https://download.gocd.org/GOCD-GPG-KEY.asc | gpg --dearmor | sudo tee /usr/share/keyrings/gocd.gpg > /dev/null 2>&1
Füge das GoCD-Repository zum System hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/gocd.gpg] https://download.gocd.org /" | sudo tee /etc/apt/sources.list.d/gocd.list
Aktualisiere die Liste der Repositories im System.
$ sudo apt update
Installiere GoCD. Dadurch wird auch die neueste kompatible Version der Java Runtime (JRE) installiert, die für die Ausführung von GoCD erforderlich ist.
$ sudo apt install -y go-server
Bevor wir mit dem nächsten Schritt fortfahren, müssen wir ein Verzeichnis erstellen, in dem die Artefakte gespeichert werden. Die Artefakte können entweder auf der gleichen Festplatte gespeichert werden, auf der auch der Server installiert ist, oder auf einer eigenen Festplatte oder einem Blockspeicherlaufwerk. Für diesen Lehrgang werden wir sie auf derselben Festplatte speichern.
Erstelle ein Verzeichnis zum Speichern der Artefakte.
$ sudo mkdir /opt/artifacts
Gib GoCD die Eigentümerschaft für das Artefaktverzeichnis.
$ sudo chown -R go:go /opt/artifacts
Schritt 3 – PostgreSQL installieren und konfigurieren
GoCD wird standardmäßig mit der H2-Datenbank ausgeliefert, die keine Konfiguration erfordert. Wenn du GoCD in einer Produktionsumgebung verwendest, wird PostgreSQL empfohlen.
Ubuntu 22.04 wird mit einer älteren Version von PostgreSQL ausgeliefert. Für unseren Lehrgang werden wir PostgreSQL 15 installieren.
Installiere das Repository für PostgreSQL.
$ sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Importiere den PostgreSQL GPG-Schlüssel.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/apt.postgresql.org.gpg >/dev/null
Aktualisiere die Liste der System-Repositories.
$ sudo apt update
Installiere den PostgreSQL 15 Server.
$ sudo apt install -y postgresql postgresql-contrib
Überprüfe den Status des Dienstes.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2022-12-19 06:49:50 UTC; 2h 26min ago
Main PID: 3536 (code=exited, status=0/SUCCESS)
CPU: 1ms
Dec 19 06:49:50 gocd systemd[1]: Starting PostgreSQL RDBMS...
Dec 19 06:49:50 gocd systemd[1]: Finished PostgreSQL RDBMS.
Melde dich in der PostgreSQL-Shell an.
$ sudo -i -u postgres psql
Erstelle eine neue Datenbank für GoCD.
postgres=# CREATE DATABASE "gocd" ENCODING="UTF8" TEMPLATE="template0";
Erstelle einen neuen Datenbankbenutzer mit einem sicheren Passwort.
postgres=# CREATE ROLE "gocd_database_user" PASSWORD 'gocd_database_password' NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT LOGIN;
Erteile dem Benutzer die Rechte zur Nutzung der Datenbank.
postgres=# GRANT ALL PRIVILEGES ON DATABASE "gocd" TO "gocd_database_user";
Erteile dem Benutzer Superuser-Rechte. Der Datenbankbenutzer benötigt nur beim ersten Start des GoCD-Servers Superuser-Rechte. Das ist notwendig, weil die Erweiterungen pgcrypto und citext zunächst erstellt werden müssen. Das Superuser-Recht kann nach dem ersten Start des GoCD-Servers wieder entzogen werden, da es nicht mehr benötigt wird.
postgres-=# ALTER ROLE "gocd_database_user" SUPERUSER;
Beende die Postgres-Shell.
postgres=# \q
Der letzte Schritt bei der Konfiguration von PostgreSQL für GoCD besteht darin, die Zugangsdaten für die Datenbank im Konfigurationsverzeichnis des GoCD-Servers zu speichern.
Erstelle die Datei db.properties und öffne sie zur Bearbeitung.
$ sudo nano /etc/go/db.properties
Füge den folgenden Code in die Datei ein.
db.driver=org.postgresql.Driver db.url=jdbc:postgresql://localhost:5432/gocd db.user=gocd_database_user db.password=gocd_database_password
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 4 – GoCD konfigurieren
Bevor wir GoCD konfigurieren, müssen wir den GoCD-Server starten.
Starte den GoCD-Server.
$ sudo systemctl start go-server
Überprüfe den Status des Servers.
$ sudo systemctl status go-server
? go-server.service - go-server
Loaded: loaded (/etc/systemd/system/go-server.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2022-12-15 08:53:10 UTC; 8s ago
Process: 8475 ExecStart=/usr/share/go-server/bin/go-server start sysd (code=exited, status=0/SUCCESS)
Main PID: 8541 (wrapper-linux-x)
Tasks: 43 (limit: 2237)
Memory: 566.7M
CPU: 11.873s
CGroup: /system.slice/go-server.service
??8541 /usr/share/go-server/bin/../wrapper/wrapper-linux-x86-64 /usr/share/go-server/wrapper-config/wrapper.conf wrapper.syslog.ident=go-server wrapper.pidfile=/var/lib/go-server/run/go-server.pi>
??8556 /usr/share/go-server/jre/bin/java --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED -Xms512m -Xmx1024m -XX:MaxMetaspaceSize=400m .....
Starte das GoCD-Dashboard, indem du die URL http://<yourserverIP>:8153/ aufrufst. Um über eine sichere Verbindung auf das GoCD-Dashboard zuzugreifen, besuche die URL https://<yourserverIP>:8154. Ignoriere die Fehlermeldung, dass die Zertifikate ungültig sind. Es ist immer wichtig, dass du über eine sichere Verbindung auf das Dashboard zugreifst.
Du wirst die folgende Seite erhalten.
Bevor du sie benutzt, solltest du GoCD konfigurieren. Gehe dazu in der oberen Navigationsleiste auf das Menü Admin >> Serverkonfiguration.
Füge die URL der Website in die vorgesehenen Felder ein und klicke auf die Schaltfläche Speichern.
Klicke im linken Menü auf die Option Artefaktverwaltung und gib den Speicherort des zuvor erstellten Artefaktverzeichnisses ein. Wähle die Option Automatische Bereinigung von Artefakten zulassen, um den Speicherplatz zu verwalten, und lege die Kapazität entsprechend deinen Anforderungen fest. Klicke auf die Schaltfläche Speichern, wenn du fertig bist.
Die Option zum automatischen Löschen erstellt jedoch kein Backup deiner alten Artefakte. Um manuell ein Backup zu erstellen und dann die alten Artefakte zu löschen, deaktiviere die automatische Löschung, indem du die Option Automatische Artefaktbereinigung zulassen abwählst.
Als nächstes müssen wir die E-Mail-Optionen konfigurieren, um E-Mail-Benachrichtigungen von GoCD zu erhalten.
Klicke auf die Schaltfläche Test-E-Mail senden, um die Einstellungen zu überprüfen, und klicke dann zum Abschluss auf die Schaltfläche Speichern.
Wenn du die Dauer des Job-Timeouts festlegen möchtest, kannst du dies im Abschnitt Job-Timeout-Konfiguration tun.
Starte den GoCD Server neu, um die Änderungen zu übernehmen.
$ sudo systemctl restart go-server
Schritt 5 – GoCD-Authentifizierung einrichten
Standardmäßig ist GoCD für jeden zugänglich, aber du kannst die Authentifizierung mit einer Passwortdatei oder LDAP konfigurieren. In diesem Lernprogramm werden wir die passwortbasierte Authentifizierung einrichten.
Installiere die Apache-Tools, damit wir mit dem Befehl htpasswd eine verschlüsselte Passwortdatei erstellen können.
$ sudo apt install apache2-utils
Erstelle eine Passwortdatei mit der Bcrypt-Authentifizierung. Das -c Flag erstellt eine neue Datei, das -B Flag legt die Bcrypt-Authentifizierung fest und das goadmin ist der Nutzername.
$ sudo htpasswd -B -c /etc/go/passwd_auth navjot
Gib das Passwort ein, wenn du dazu aufgefordert wirst.
New password: Re-type new password: Adding password for user navjot
Du kannst mit demselben Befehl mehrere Benutzer hinzufügen, musst aber das Flag -c entfernen, da die Datei bereits existiert. Wenn du das -c Flag erneut verwendest, wird die bestehende Datei überschrieben und der bestehende Benutzer durch den neuen Benutzer ersetzt.
$ sudo htpasswd -B /etc/go/passwd_auth gouser1
Der nächste Schritt bei der Authentifizierung ist die Konfiguration des Passwortspeichers im GoCD-Backend. Gehe in der oberen Navigationsleiste zu Admin >> Sicherheit >> Berechtigungskonfiguration.
Klicke auf die Schaltfläche Hinzufügen und gib eine beliebige ID an. Wähle für die Plugin-ID das Plugin Password File Authentication Plugin for GoCD aus dem Dropdown-Menü und gib den Pfad der Passwortdatei ein. Klicke anschließend auf die Schaltfläche Verbindung prüfen, um zu überprüfen, ob GoCD auf die Datei zur Authentifizierung zugreifen kann.
Lasse für den ersten Benutzer die Option Nur bekannten Benutzern die Anmeldung erlauben unmarkiert. Klicke zum Abschluss auf die Schaltfläche Speichern.
Du wirst bald aufgefordert, GoCD zu aktualisieren und gelangst zur Anmeldeseite.
Gib die zuvor erstellten Anmeldedaten ein und klicke auf die Schaltfläche Anmelden, um fortzufahren. Rufe den Bereich Verwaltung >> Sicherheit >> Benutzerverwaltung in der oberen Navigationsleiste auf.
Markiere das Kästchen SYSTEM ADMIN, um den Benutzer als Administrator zu kennzeichnen. Gehe nun zurück zum Abschnitt Admin >> Sicherheit >> Berechtigungskonfiguration und klicke auf die Schaltfläche Bearbeiten über der Auflistung der Passwortdatei.
Aktiviere die Option Nur bekannten Benutzern die Anmeldung erlauben. Von nun an musst du einen neuen Benutzer über die Datei htpasswd erstellen und ihn dann zuerst von der Server-Seite importieren.
Lass uns einen zweiten Benutzer erstellen.
$ sudo htpasswd -B /etc/go/passwd_auth gouser1 New password: Re-type new password: Adding password for user gouser1
Besuche den Bereich Admin >> Sicherheit >> Benutzerverwaltung im oberen Navigationsmenü und klicke auf die Schaltfläche Benutzer importieren. Gib den Benutzernamen gouser1 ein, um nach dem Benutzer zu suchen.
Wähle den Benutzer aus und klicke auf die Schaltfläche Importieren, um den Benutzer hinzuzufügen.
Jetzt kannst du dich auch mit dem zweiten Benutzer anmelden. Wiederhole den Vorgang für weitere Benutzer.
Schritt 6 – Nginx installieren
Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \ http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \ | sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.22.1
Starte den Nginx-Server.
$ sudo systemctl start nginx
Schritt 7 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d gocd.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/gocd.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 8 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/gocd.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/gocd.conf
Füge den folgenden Code in die Datei ein.
server {
# Redirect any http requests to https
listen 80;
listen [::]:80;
server_name gocd.example.com;
return 301 https://$host$request_uri;
}
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name gocd.example.com;
access_log /var/log/nginx/gocd.access.log;
error_log /var/log/nginx/gocd.error.log;
# TLS configuration
ssl_certificate /etc/letsencrypt/live/gocd.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/gocd.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/gocd.example.com/chain.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
ssl_session_timeout 1d;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# Proxy everything over to the GoCD server
location / {
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
proxy_pass http://localhost:8153/;
# To be able to upload artifacts larger than default size of 1mb, ensure that you set this up to a large value.
# setting to `0` will disable checking for body size.
# See https://nginx.org/en/docs/http/ngx_http_core_module.html#client_max_body_size
client_max_body_size 10000m;
# If you are intending to allow downloading of large artifacts (> 1GB) from GoCD you may need to adjust one of the
# following two proxy buffering settings to prevent downloads failing for slow clients due to server idle timeouts.
#
# See https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_buffering
#
# 1) disable the buffering of responses entirely (enabled by default on NGINX) OR
# proxy_buffering off;
#
# 2) increase the max temporary file size (setting to `0` will disable the limit)
# proxy_max_temp_file_size 2048m;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Du kannst jetzt über die URL https://gocd.example.com auf das GoCD Dashboard zugreifen.
Schritt 9 – GoCD Agent installieren
GoCD Agents sind die Worker, die für die Ausführung aller Aufgaben verantwortlich sind. Wenn eine Änderung in der Quelle festgestellt wird, wird die Pipeline ausgelöst und die Aufgaben werden den verfügbaren Workern zur Ausführung zugewiesen. Der Agent führt dann die Aufgabe aus und meldet den endgültigen Status nach der Ausführung.
Um die Pipeline zu starten, muss mindestens ein Agent konfiguriert werden. Installieren wir den GoCD-Agenten auf dem GoCD-Server.
Da wir das GoCD-Repository bereits importiert haben, installieren wir den GoCD-Agenten direkt.
$ sudo apt install go-agent
Starten Sie den GoCD-Agentendienst.
$ sudo systemctl start go-agent
Besuche die Registerkarte Agenten in deinem GoCD-Dashboard und du solltest sehen, dass der Agent aufgelistet und automatisch aktiviert ist.
Von hier aus kannst du den GoCD CI/CD-Dienst nutzen.
Fazit
Damit ist unser Tutorium abgeschlossen. Du hast gelernt, wie du GoCD auf einem Ubuntu 22.04 Server installierst und konfigurierst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.