TOC

So konfigurieren Sie GoCD mit Let’s Encrypt SSL Certificates unter Ubuntu 16.04

Einführung

GoCD ist eine leistungsstarke kontinuierliche Integrations- und Bereitstellungsplattform zur Automatisierung von Test- und Freigabeprozessen. Mit vielen erweiterten Funktionen wie der Möglichkeit, Builds zu vergleichen, komplexe Workflows zu visualisieren und die Versionsverfolgung von Builds zu automatisieren, ist GoCD ein flexibles Tool, mit dem Teams gut getestete Software für Produktionsumgebungen bereitstellen können.

Im letzten Artikel haben wir https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-gocd-on-ubuntu-16-04 den GoCD-Server installiert, einen Agenten eingerichtet, und konfigurierte Authentifizierung]. In diesem Handbuch konfigurieren wir GoCD für die Verwendung eines vertrauenswürdigen Let’s Encrypt SSL-Zertifikats, um Browser-Warnungen beim Zugriff auf die Weboberfläche zu verhindern. Wir werden Anweisungen für zwei verschiedene mögliche Konfigurationen bereitstellen.

Bei der ersten Methode wird ein Nginx-Webserver als Reverse-Proxy installiert, der Verbindungen zum HTTP-Endpunkt von GoCD weiterleitet. Diese Option bietet eine nahtlosere Let’s Encrypt-Funktion und ist wahrscheinlich die beste Option für die meisten Benutzer.

Die zweite Methode, die wir diskutieren werden, bezieht ein Zertifikat von Let’s Encrypt und schaltet dann das Zertifikat aus, das vom HTTPS-Endpunkt von GoCD verwendet wird. Dadurch entfällt zwar die Notwendigkeit eines separaten Webservers, wodurch möglicherweise Ressourcen gespart werden. GoCD verwendet jedoch das Java-Keystore-SSL-Zertifikat-Repository, das nicht direkt mit dem von Let’s Encrypt angebotenen Zertifikatformat kompatibel ist. Wir müssen ein Skript erstellen, um die Zertifikate bei jeder Erneuerung automatisch in das erwartete Format zu konvertieren. Diese Option ist am besten geeignet, wenn Ihr Server nur über minimale Ressourcen verfügt und Sie alles, was für GoCD verfügbar ist, selbst zuweisen möchten.

Voraussetzungen

Wenn Sie unter Ubuntu 16.04 noch keinen GoCD-Server konfiguriert haben, müssen Sie einen konfigurieren, bevor Sie dieses Handbuch starten. Der Basisserver benötigt * mindestens 2 GB RAM und 2 CPU-Kerne *. GoCD benötigt auch eine dedizierte Partition oder Festplatte für die Speicherung von Artefakten. In einem dieser beiden Handbücher erfahren Sie, wie Sie diesen zusätzlichen Speicherplatz konfigurieren:

Nach dem Einrichten des Servers können Sie eine Erstkonfiguration durchführen und GoCD mithilfe der folgenden Anleitungen installieren:

  • Initial Server Setup mit Ubuntu 16.04: In diesem Handbuch erfahren Sie, wie Sie einen "+ sudo +" - Benutzer erstellen und richten Sie eine grundlegende Firewall ein.

  • https://www.digitalocean.com/community/tutorials/installations- und konfigurationsanleitung-gocd-on-ubuntu-16-04[Installation und Konfiguration von GoCD unter Ubuntu 16.04]: Diese Anleitung wird Sie führen durch Installieren der Software, Konfigurieren eines Artefakt-Bereitstellungspunkts und Einrichten der Benutzerauthentifizierung.

Um ein SSL-Zertifikat von Let’s Encrypt zu erhalten, muss Ihr Server über einen * Domainnamen * verfügen.

Weitere Anforderungen hängen von der gewünschten Methode ab und werden in den entsprechenden Abschnitten erläutert. Wenn Sie fortfahren möchten, wählen Sie die Methode aus, die Sie verwenden möchten, und befolgen Sie die zugehörigen Anweisungen.

Option 1: Konfigurieren von Nginx als Reverse Proxy für GoCD

Wenn Sie Nginx als SSL-terminierenden Reverse-Proxy für GoCD einrichten möchten, befolgen Sie diesen Abschnitt. In dieser Konfiguration wird Nginx so konfiguriert, dass HTTPS-Datenverkehr mithilfe des Let’s Encrypt-Zertifikats bereitgestellt wird. Es entschlüsselt Clientverbindungen und leitet den Datenverkehr über normales HTTP an die GoCD-Weboberfläche weiter. Dies erfordert zusätzlichen Aufwand für das Nginx-Frontend, ist jedoch einfacher.

Zusätzliche Anforderungen

Wenn Sie Nginx als Reverse-Proxy für GoCD verwenden möchten, müssen Sie zuerst Nginx und den Let’s Encrypt-Client installieren und anschließend ein Zertifikat für Ihre Domain anfordern. Diese Tutorials enthalten die erforderlichen Schritte, um ein Zertifikat zu erhalten und Ihren Webserver zu konfigurieren:

Nachdem Sie die obigen Anleitungen ausgefüllt haben, sollte GoCD weiterhin mit dem selbstsignierten Zertifikat erreichbar sein, indem Sie auf "+ https: //: 8154 +" zugreifen, und die Standard-Nginx-Seite sollte mit dem "Let’s Encrypt" -Zertifikat angezeigt werden, wenn Sie den Port entfernen Spezifikation.

Jetzt können wir Nginx so konfigurieren, dass Proxy-Anforderungen an das GoCD-Backend gesendet werden, damit die Client-Verbindungen mit dem Let’s Encrypt-Zertifikat verschlüsselt werden.

Konfigurieren von Nginx To Proxy für das HTTP-Webinterface von GoCD

Wir haben ein SSL-Zertifikat von Let’s Encrypt heruntergeladen und Nginx so konfiguriert, dass es das Zertifikat verwendet, wenn Anforderungen an den Standard-SSL-Port gesendet werden. Unser nächster Schritt besteht darin, Nginx so zu konfigurieren, dass es diese Anforderungen an die reguläre HTTP-Webschnittstelle von GoCD weiterleitet, die auf Port 8153 verfügbar ist.

Öffnen Sie zunächst die Standard-Nginx-Serverblockdatei, die für die Verwendung Ihres Let’s Encrypt-Zertifikats konfiguriert ist:

sudo nano /etc/nginx/sites-available/default

Öffnen Sie oben in der Datei außerhalb des Blocks "+ server " einen neuen Abschnitt " upsteam ". Wir werden diesen Block " gocd +" nennen, damit wir ihn später leicht erkennen können. Geben Sie in das Feld die Adresse ein, über die Nginx die HTTP-Schnittstelle von GoCD kontaktieren kann. In unserem Fall würde dies das lokale Loopback-Gerät verwenden, daher sollte die vollständige Adresse "+127.0.0.1: 8153 +" lauten:

/ etc / nginx / sites-available / default

server {
   . . .

Suchen Sie als Nächstes im Block "+ server " den Block " location / ". Kommentieren Sie die Direktive ` try_files` aus, damit wir Ihre Proxy-Konfiguration angeben können. Fügen Sie anstelle der Zeile "+ try_files " einen Proxy-Pass zum von uns definierten " gocd " -Upstream hinzu, indem Sie das " http: // " -Protokoll verwenden. Fügen Sie die Datei ` proxy_params +` hinzu, um die anderen Proxy-Einstellungen festzulegen, die für unseren Standortblock erforderlich sind:

/ etc / nginx / sites-available / default

. . .

server
   . . .

   location / {
       try_files $uri $uri/ =404;


   }

   . . .

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wenn Sie wieder in der Befehlszeile sind, überprüfen Sie die Nginx-Konfiguration auf Syntaxfehler, indem Sie Folgendes eingeben:

sudo nginx -t

Wenn keine Fehler gefunden werden, starten Sie den Nginx-Dienst neu, indem Sie Folgendes eingeben:

sudo systemctl restart nginx

Ihre GoCD-Weboberfläche sollte nun über Ihren regulären Domainnamen mit dem Protokoll "+ https: // +" erreichbar sein.

Das letzte Element, das wir anpassen müssen, ist die Site-URL-Einstellung in der Web-Benutzeroberfläche von GoCD.

Aktualisieren der URL der GoCD-Site zur Verwendung der neuen Adresse

Nach dem Neustart von Nginx besteht die einzige verbleibende Aufgabe darin, die Site-URL-Einstellung zu ändern, die GoCD intern verwendet, um entsprechende Links zu erstellen.

Besuchen Sie Ihre GoCD-Serverdomäne in Ihrem Webbrowser und melden Sie sich bei Bedarf an:

https://

Klicken Sie anschließend in der oberen Menüleiste auf * ADMIN * und wählen Sie im Dropdown-Menü die Option * Serverkonfiguration * aus:

image: https: //assets.digitalocean.com/articles/gocd_ssl_1604/config_server_link.png [GoCD configure server link]

Ändern Sie im Abschnitt * Serververwaltung * die * Site-URL *, um die Anschlussspezifikation +: 8154 + am Ende zu entfernen. Wenn Sie zuvor eine IP-Adresse anstelle eines Domainnamens verwendet haben, ändern Sie die URL so, dass auch Ihr Domainname verwendet wird:

image: https: //assets.digitalocean.com/articles/gocd_ssl_1604/site_url_setting.png [URL-Einstellung für GoCD-Site]

Scrollen Sie zum Ende der Seite und klicken Sie auf * SPEICHERN *, um die Änderung sofort zu übernehmen. Ihre Site ist nun so eingerichtet, dass alle Anfragen für Ihre Domain über Nginx an die GoCD-Web-Benutzeroberfläche weitergeleitet werden.

Option 2: Konfigurieren von GoCDs nativem SSL für die Verwendung von Let’s Encrypt Certificates

Befolgen Sie diesen Abschnitt, wenn Sie den GoCD-eigenen Webserver für die Verwendung von Let’s Encrypt-Zertifikaten konfigurieren möchten. In dieser Konfiguration ersetzen wir das selbstsignierte Zertifikat, das bereits vom GoCD-Server verwendet wird, durch ein vertrauenswürdiges Zertifikat, das von Let’s Encrypt bereitgestellt wird. Dazu müssen wir die Zertifikatsdateien in ein neues Format konvertieren und sie in eine Java-Keystore-Datei importieren. Wir erstellen ein Skript, damit der Vorgang jedes Mal wiederholt werden kann, wenn die Zertifikatdateien erneuert werden.

Zusätzliche Anforderungen

Wenn Sie alle SSL-Vorgänge in GoCD selbst ausführen möchten, müssen Sie ein Zertifikat von Let’s Encrypt herunterladen, ohne den Webserver konfigurieren zu müssen. Befolgen Sie diese Anleitung, um den entsprechenden Client herunterzuladen und ein Zertifikat für Ihre Domain zu erhalten:

Nachdem Sie die oben genannten Anleitungen ausgefüllt haben, sollte GoCD weiterhin mit dem selbstsignierten Zertifikat erreichbar sein, indem Sie auf "+ https: //: 8154 " zugreifen. Die von Let's Encrypt bereitgestellten Zertifikatdateien sollten in " / etc / letsencrypt" verfügbar sein / live / + `Verzeichnis.

Erstellen des Zertifikatsumwandlungsskripts

GoCD verwendet einen Java keystore, um SSL-Zertifikate zu verarbeiten. Leider ist dies ein anderes Format als das von Let’s Encrypt verwendete. Um unsere Let’s Encrypt-Zertifikate mit GoCD verwenden zu können, müssen wir sie nach einem ganz bestimmten Verfahren konvertieren.

Aufgrund der Komplexität des Verfahrens und der Notwendigkeit, Zertifikate bei jeder Erneuerung zu konvertieren, erstellen wir ein Skript zur Automatisierung des Verfahrens. Erstellen und öffnen Sie im Verzeichnis "+ / usr / local / bin " ein Skript mit dem Namen " convert_certs_for_gocd.sh +" in Ihrem Texteditor:

sudo nano /usr/local/bin/convert_certs_for_gocd.sh

Fügen Sie das folgende Skript ein. Die einzige Einstellung, die Sie aktualisieren müssen, ist der Wert der Variablen "+ base_domain ". Stellen Sie dies auf den Domainnamen Ihres GoCD-Servers ein (dieser sollte mit dem Wert des Verzeichnisses in " / etc / letsencrypt / live / +" übereinstimmen):

/usr/local/bin/convert_certs_for_gocd.sh

#!/bin/bash

base_domain=""
le_directory="/etc/letsencrypt/live/${base_domain}"
working_dir="$(mktemp -d)"
gocd_pass="serverKeystorepa55w0rd"


clean_up () {
   rm -rf "${working_dir}"
}

# Use this to echo to standard error
error () {
   printf "%s: %s\n" "$(basename "${BASH_SOURCE}")" "${1}" >&2
   clean_up
   exit 1
}

trap 'error "An unexpected error occurred."' ERR

copy_cert_files () {
   cp "${le_directory}/fullchain.pem" "${working_dir}"
   cp "${le_directory}/privkey.pem" "${working_dir}"
}

convert_to_pkcs12 () {
   openssl_pkcs12_args=(
       "pkcs12"
       "-inkey" "${working_dir}/privkey.pem"
       "-in" "${working_dir}/fullchain.pem"
       "-export"
       "-out" "${working_dir}/${base_domain}.crt.pkcs12"
       "-passout" "pass:${gocd_pass}"
   )
   openssl "${openssl_pkcs12_args[@]}"
}

import_to_keytool () {
   keytool_args=(
       "-importkeystore"
       "-srckeystore" "${working_dir}/${base_domain}.crt.pkcs12"
       "-srcstoretype" "PKCS12"
       "-srcstorepass" "${gocd_pass}"
       "-destkeystore" "${working_dir}/keystore"
       "-srcalias" "1"
       "-destalias" "cruise"
       "-deststorepass" "${gocd_pass}"
       "-destkeypass" "${gocd_pass}"
   )
   keytool "${keytool_args[@]}"
}

install_new_keystore () {
   cp /etc/go/keystore /etc/go/keystore.bak
   mv "${working_dir}/keystore" "/etc/go/keystore"
   chown go:go /etc/go/keystore
   systemctl restart go-server
}

if (( EUID != 0 )); then
   error "This script requires root privileges"
fi

copy_cert_files && convert_to_pkcs12 && import_to_keytool && install_new_keystore && clean_up

Lassen Sie uns genau untersuchen, was dieses Skript tut.

Zu Beginn haben wir einige Variablen festgelegt, um die Arbeit mit unserem Skript zu erleichtern. Wir legen den Domänennamen für die zu konvertierenden Zertifikate und eine Variable fest, die in das Let’s Encrypt-Zertifikatverzeichnis erweitert wird. Wir erstellen ein temporäres Arbeitsverzeichnis mit dem Befehl + mktemp + und weisen den Wert einer anderen Variablen zu. GoCD erfordert, dass alle Java-Keystore-Passwörter "+ serverKeystorepa55w0rd +" sind `, setzen wir eine andere Variable, um diesen Wert zu halten.

Als nächstes definieren wir eine Funktion, die das temporäre Verzeichnis beim Aufruf löscht. Wir verwenden dies am Ende unseres Skripts, um nach uns selbst aufzuräumen und auch, wenn unerwartete Fehler auftreten. Um diese zweite Möglichkeit zu erreichen, erstellen wir eine weitere Funktion, die eine Fehlermeldung anzeigt und vor dem Beenden bereinigt. Wir verwenden den Befehl "+ trap +", um diese Funktion automatisch aufzurufen, wenn ein Fehler auftritt.

Anschließend erstellen wir die Funktionen, die die eigentliche Konvertierung durchführen. Die erste Funktion richtet unseren Arbeitsbereich ein, indem der private Schlüssel und das vollständige Kettenzertifikat in das Arbeitsverzeichnis kopiert werden. Die Funktion + convert_to_pkcs12 + verwendet + openssl +, um die vollständige Kettenzertifikatsdatei und die private Schlüsseldatei in der kombinierten PKCS 12 file zu verknüpfen, die das Keytool verwendet. Für diesen Vorgang ist ein Exportkennwort erforderlich, daher verwenden wir die GoCD-Kennwortvariable.

Die nächste Funktion importiert die neue PKCS 12-Datei in eine Java-Keystore-Datei. Wir importieren die Datei und geben das Export-Passwort an. Wir geben dann dasselbe Passwort für die verschiedenen Passwörter der Keystore-Datei ein. Schließlich kopiert die letzte Funktion die neue "+ keystore " -Datei in das " / etc / go " -Verzeichnis (nach dem Sichern des alten " keystore +"), passt den Dateibesitz an und startet den GoCD-Server neu.

Am Ende des Skripts prüfen wir, ob das Skript mit den entsprechenden Berechtigungen aufgerufen wird, indem wir prüfen, ob die effektive Benutzer-ID "0" ist, was "mit den gleichen Berechtigungen wie root" bedeutet. Rufen Sie dann die Funktionen in der entsprechenden Reihenfolge auf, um die Zertifikate korrekt zu konvertieren und die neue Datei + keystore + zu installieren.

Wenn Sie fertig sind, speichern und schließen Sie die Datei, um fortzufahren.

Erstkonvertierung durchführen

Nachdem wir nun ein Konvertierungsskript haben, sollten wir es verwenden, um die anfängliche Zertifikatkonvertierung durchzuführen.

Markieren Sie zuerst das Skript als ausführbar, damit es direkt ausgeführt werden kann, ohne einen Interpreter aufzurufen:

sudo chmod +x /usr/local/bin/convert_certs_for_gocd.sh

Rufen Sie nun das Skript mit + sudo + auf, um die Erstkonvertierung durchzuführen, installieren Sie die generierte + keystore + - Datei und starten Sie den GoCD-Prozess neu

sudo /usr/local/bin/convert_certs_for_gocd.sh

Da der GoCD-Server neu gestartet werden muss, kann der Vorgang einige Zeit dauern. Nach Abschluss des Skripts kann es einen oder zwei Sekunden dauern, bis der Server bereit ist, auf Verbindungen zu warten. Sie können die derzeit von Anwendungen verwendeten Ports überwachen, indem Sie Folgendes eingeben:

sudo watch netstat -plnt

In dieser Ansicht werden die TCP-Ports angezeigt, die derzeit von Anwendungen mit einer Aktualisierungsrate von zwei Sekunden abgehört werden. Wenn GoCD die Ports 8153 und 8154 abhört, sollte der Bildschirm folgendermaßen aussehen:

OutputEvery 2.0s: netstat -plnt                                                    Thu Jul 27 20:16:20 2017

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1736/sshd
tcp6       0      0 :::22                   :::*                    LISTEN      1736/sshd
tcp6       0      0 :::                 :::*                    LISTEN      8942/java
tcp6       0      0 :::                 :::*                    LISTEN      8942/java

Sobald die Ports 8153 und 8154 vorhanden sind, drücken Sie * STRG-C *, um die Anzeige zu verlassen.

Nachdem die Anwendung Verbindungen abgehört hat, überprüfen Sie die Webschnittstelle, indem Sie Ihre GoCD-Domäne an Port 8154 mit HTTPS besuchen:

https://:8154

Zuvor gab ein Symbol in der Adressleiste beim Zugriff auf diese Seite an, dass das Zertifikat nicht als vertrauenswürdig eingestuft werden konnte (beachten Sie, dass die visuelle Anzeige Ihres Browsers möglicherweise anders ist):

image: https://assets.digitalocean.com/articles/gocd_ssl_1604/ssl_cert_not_trusted_icon.png [Chrome SSL-Zertifikat nicht vertrauenswürdiges Symbol]

Beim ersten Besuch mussten Sie wahrscheinlich durch einen Warnbildschirm in Ihrem Browser klicken:

image: https://assets.digitalocean.com/articles/gocd_install_1604/browser_ssl_warning.png [Browser-SSL-Warnung]

Nachdem wir das selbstsignierte Zertifikat durch ein vertrauenswürdiges Zertifikat ersetzt haben, das von Let’s Encrypt bereitgestellt wird, zeigt der Browser an, dass das Zertifikat vertrauenswürdig ist, und Benutzer müssen keine Browser-Warnung umgehen, um auf die Site zuzugreifen. Beachten Sie, dass das vorherige Zertifikat möglicherweise von Ihrem Browser zwischengespeichert wird, bis Sie die aktuelle Registerkarte, das aktuelle Fenster oder die aktuelle Sitzung schließen:

image: https: //assets.digitalocean.com/articles/gocd_ssl_1604/ssl_cert_trusted_icon.png [Chrome SSL cert trusted icon]

Dies bedeutet, dass GoCD das von uns konvertierte Let’s Encrypt-Zertifikat verwenden konnte.

Einrichten eines Hooks zur automatischen Verlängerung

Nachdem wir überprüft haben, dass unser Skript die Zertifikatsbestände korrekt konvertiert hat, können wir sicherstellen, dass "+ certbot +" unser Skript jedes Mal aufruft, wenn das Zertifikat erneuert wird.

Öffnen Sie die Erneuerungskonfigurationsdatei für Ihre Domain im Verzeichnis "+ / etc / letsencrypt / renewal +", indem Sie Folgendes eingeben:

sudo nano /etc/letsencrypt/renewal/.conf

Fügen Sie im Abschnitt "+ [renewalparams] " der Datei eine Zeileneinstellung " renew_hook +" zum Speicherort Ihres Skripts hinzu:

/etc/letsencrypt/renewal/example.com.conf

. . .
[renewalparams]
. . .
renew_hook = /usr/local/bin/convert_certs_for_gocd.sh

Die Software "+ certbot " installiert einen " cron " - Job, der prüft, ob Zertifikate zweimal täglich erneuert werden sollten. Nach der Erneuerung eines Zertifikats wird das mit ` renew_hook +` angegebene Skript ausgeführt. Auf diese Weise können wir sicherstellen, dass GoCD immer das neueste gültige Zertifikat verwendet, das von Let’s Encrypt erworben wurde.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Sie können testen, ob Sie keine Syntaxfehler in die Datei eingefügt haben, indem Sie die Erneuerungsprozedur im Probelauf ausführen. Beachten Sie, dass hierdurch unser Zertifikatkonvertierungsskript nicht ausgeführt wird. Es wird jedoch ein Hinweis darüber ausgegeben, dass es übersprungen wird:

sudo certbot renew --dry-run
OutputSaving debug log to /var/log/letsencrypt/letsencrypt.log

-------------------------------------------------------------------------------
Processing /etc/letsencrypt/renewal/.conf
-------------------------------------------------------------------------------
Cert not due for renewal, but simulating renewal for dry run
Renewing an existing certificate
Performing the following challenges:
http-01 challenge for
Waiting for verification...
Cleaning up challenges


-------------------------------------------------------------------------------
new certificate deployed without reload, fullchain is
/etc/letsencrypt/live//fullchain.pem
-------------------------------------------------------------------------------
** DRY RUN: simulating 'certbot renew' close to cert expiry
**          (The test certificates below have not been saved.)

Congratulations, all renewals succeeded. The following certs have been renewed:
 /etc/letsencrypt/live//fullchain.pem (success)
** DRY RUN: simulating 'certbot renew' close to cert expiry
**          (The test certificates above have not been saved.)

Die obige Ausgabe bestätigt, dass die von uns vorgenommenen Änderungen die Erneuerung des Zertifikats nicht verhindert haben. Die Ausgabe zeigt auch an, dass der Erneuerungshook auf den richtigen Skriptspeicherort verweist.

Fazit

In diesem Handbuch werden zwei verschiedene Methoden zum Sichern einer GoCD-Installation mit einem vertrauenswürdigen SSL-Zertifikat von Let’s Encrypt beschrieben. Bei der ersten Methode wurde das Zertifikat mit Nginx eingerichtet und anschließend der Datenverkehr an die Weboberfläche von GoCD weitergeleitet. Mit der zweiten Option wurden die Let’s Encrypt-Zertifikatdateien in das PKCS 12-Format konvertiert und in eine Java-Keystore-Datei importiert, die von GoCD nativ verwendet werden soll. Beide Optionen sichern die Weboberfläche von GoCD mit einem vertrauenswürdigen Zertifikat. Dies wird jedoch mit unterschiedlichen Strategien und mit einzigartigen Kompromissen erreicht. Welcher Ansatz für Sie geeignet ist, hängt weitgehend von den Anforderungen und Zielen Ihres Teams ab.

Related