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

  1. Ein Server mit Ubuntu 22.04 und mindestens 2 GB RAM.
  2. Ein Nicht-Sudo-Benutzer mit Root-Rechten.
  3. Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
  4. Fully Qualified Domain Names(FQDN), die auf deinen Server zeigen. Wir werden gocd.example.com für unser Tutorial verwenden.
  5. 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.

GoCD Homepage

Bevor du sie benutzt, solltest du GoCD konfigurieren. Gehe dazu in der oberen Navigationsleiste auf das Menü Admin >> Serverkonfiguration.

GoCD Server Konfigurationsmenü

Füge die URL der Website in die vorgesehenen Felder ein und klicke auf die Schaltfläche Speichern.

GoCD Server URL

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.

GoCD Artifcats Management

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.

GoCD E-Mail Server Optionen

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.

GoCD Autorisierungskonfiguration

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.

GoCD Login Seite

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.

GoCD Benutzerverwaltung

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.

GoCD Passwort Datei bearbeiten Option

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.

GoCD Import Benutzer

Wähle den Benutzer aus und klicke auf die Schaltfläche Importieren, um den Benutzer hinzuzufügen.

GoCD Users List

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 [email protected] -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.

GoCD-Agentenliste

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.

Das könnte dich auch interessieren …