Comment configurer GoCD avec les certificats SSL Let's Encrypt sur Ubuntu 16.04

De Get Docs
Aller à :navigation, rechercher

Introduction

GoCD est une puissante plate-forme d'intégration et de livraison continues conçue pour automatiser les processus de test et de publication. Avec de nombreuses fonctionnalités avancées telles que la possibilité de comparer les builds, de visualiser des flux de travail complexes et d'automatiser le suivi des versions de build, GoCD est un outil flexible qui peut aider les équipes à fournir des logiciels bien testés aux environnements de production.

Dans le dernier article, nous avons installé le serveur GoCD, configuré un agent et configuré l'authentification . Dans ce guide, nous allons configurer GoCD pour utiliser un certificat SSL Let's Encrypt de confiance afin d'empêcher les avertissements du navigateur lors de l'accès à l'interface Web. Nous fournirons des instructions pour deux configurations différentes possibles.

La première méthode installera un serveur Web Nginx en tant que proxy inverse qui transmettra les connexions au point de terminaison HTTP de GoCD. Ce choix offre une expérience Let's Encrypt plus transparente et sera probablement la meilleure option pour la plupart des gens.

La deuxième méthode dont nous parlerons consistera à acquérir un certificat de Let's Encrypt, puis à désactiver le certificat utilisé par le point de terminaison HTTPS de GoCD. Bien que cela supprime l'exigence d'un serveur Web séparé, économisant éventuellement des ressources, GoCD utilise le référentiel de certificats SSL du magasin de clés Java qui n'est pas directement compatible avec le format de certificat proposé par Let's Encrypt. Nous devrons créer un script pour convertir automatiquement les certificats au format attendu à chaque renouvellement. Cette option est la meilleure si votre serveur dispose de ressources minimales et que vous souhaitez allouer tout ce qui est disponible à GoCD lui-même.

Conditions préalables

Si vous n'avez pas encore de serveur GoCD configuré sur Ubuntu 16.04, vous devrez en configurer un avant de commencer ce guide. Le serveur de base nécessite au moins 2 Go de RAM et 2 cœurs de processeur . GoCD a également besoin d'une partition ou d'un disque dédié à utiliser pour le stockage des artefacts. Vous pouvez apprendre à configurer cet espace supplémentaire à l'aide de l'un de ces deux guides :

Une fois le serveur configuré, vous pouvez effectuer une configuration initiale et installer GoCD à l'aide de ces guides :

Pour acquérir un certificat SSL de Let's Encrypt, votre serveur devra avoir un nom de domaine '.

D'autres exigences dépendent de la méthode que vous souhaitez suivre et seront expliquées dans les sections appropriées. Lorsque vous êtes prêt à continuer, choisissez la méthode que vous souhaitez utiliser et suivez les instructions associées.

Option 1 : Configurer Nginx en tant que proxy inverse pour GoCD

Si vous souhaitez configurer Nginx en tant que proxy inverse de terminaison SSL pour GoCD, suivez cette section. Dans cette configuration, Nginx sera configuré pour servir le trafic HTTPS à l'aide du certificat Let's Encrypt. Il déchiffrera les connexions client, puis transférera le trafic vers l'interface Web de GoCD en utilisant le protocole HTTP standard. Cela nécessite des frais généraux supplémentaires pour l'interface Nginx, mais il s'agit d'une approche plus simple.

Exigences supplémentaires

Si vous souhaitez utiliser Nginx comme proxy inverse pour GoCD, vous devrez d'abord installer Nginx et le client Let's Encrypt, puis demander un certificat pour votre domaine. Ces tutoriels fournissent les étapes nécessaires pour obtenir un certificat et configurer votre serveur Web :

Une fois que vous avez terminé les guides ci-dessus, GoCD doit toujours être accessible à l'aide du certificat auto-signé en accédant à https://your_domain:8154 et la page Nginx par défaut doit être affichée à l'aide du certificat Let's Encrypt lorsque vous supprimez la spécification de port.

Maintenant, nous pouvons configurer Nginx pour envoyer des requêtes proxy au backend GoCD afin que les connexions client soient cryptées avec le certificat Let's Encrypt.

Configuration de Nginx pour proxy vers l'interface Web HTTP de GoCD

Nous avons téléchargé un certificat SSL à partir de Let's Encrypt et configuré Nginx pour utiliser le certificat lors du traitement des requêtes sur le port SSL par défaut. Notre prochaine étape consiste à configurer Nginx pour envoyer ces requêtes par proxy à l'interface Web HTTP habituelle de GoCD, disponible sur le port 8153.

Pour commencer, ouvrez le fichier de blocage du serveur Nginx par défaut configuré pour utiliser votre certificat Let's Encrypt :

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

En haut du fichier, en dehors du bloc server, ouvrez une nouvelle section upsteam. Nous appellerons ce bloc gocd afin de pouvoir le reconnaître facilement plus tard. À l'intérieur, spécifiez l'adresse que Nginx peut utiliser pour contacter l'interface HTTP de GoCD. Dans notre cas, cela utiliserait le périphérique de bouclage local, donc l'adresse complète devrait être 127.0.0.1:8153 :

/etc/nginx/sites-available/default

upstream gocd {
    server 127.0.0.1:8153;
}

server {
    . . .

Ensuite, dans le bloc server, recherchez le bloc location /. À l'intérieur, commentez la directive try_files afin que nous puissions spécifier notre configuration de proxy. À la place de la ligne try_files, ajoutez une passe proxy au gocd en amont que nous avons défini, en utilisant le protocole http://. Incluez le fichier proxy_params pour définir les autres paramètres de proxy requis par notre bloc d'emplacement :

/etc/nginx/sites-available/default

. . .

server
    . . .

    location / {
        #try_files $uri $uri/ =404;
        proxy_pass http://gocd;
        include proxy_params;
    }
    
    . . .

Enregistrez et fermez le fichier lorsque vous avez terminé.

Une fois de retour sur la ligne de commande, vérifiez la configuration de Nginx pour les erreurs de syntaxe en tapant :

sudo nginx -t

Si aucune erreur n'est détectée, redémarrez le service Nginx en tapant :

sudo systemctl restart nginx

Votre interface utilisateur Web GoCD devrait maintenant être accessible via votre nom de domaine habituel avec le protocole https://.

Remarque : Bien que nous envoyions des requêtes par proxy sur les ports 80 et 443 via Nginx, nous devons toujours garder le port HTTPS 8154 ouvert dans notre pare-feu. Les agents GoCD doivent pouvoir contacter directement le serveur GoCD (sans proxy) afin que le serveur puisse valider directement le certificat SSL du client. Laisser le port 8154 ouvert permettra aux agents externes de contacter correctement le serveur tandis que les requêtes Web régulières via le navigateur peuvent passer par le proxy.


Le dernier élément que nous devons ajuster est le paramètre URL du site dans l'interface utilisateur Web de GoCD.

Mise à jour de l'URL du site GoCD pour utiliser la nouvelle adresse

Une fois que vous avez redémarré Nginx, la seule tâche restante consiste à modifier le paramètre d'URL du site que GoCD utilise en interne pour créer des liens appropriés.

Visitez votre domaine de serveur GoCD dans votre navigateur Web et connectez-vous si nécessaire :

https://example.com

Ensuite, cliquez sur ADMIN dans la barre de menu supérieure et sélectionnez Configuration du serveur dans le menu déroulant :

Dans la section Server Management, modifiez Site URL pour supprimer la spécification de port :8154 à la fin. Si vous utilisiez auparavant une adresse IP au lieu d'un nom de domaine, modifiez l'URL pour utiliser également votre nom de domaine :

Faites défiler vers le bas de la page et cliquez sur SAVE pour mettre en œuvre la modification immédiatement. Votre site est maintenant configuré pour transmettre par proxy toutes les demandes de votre domaine via Nginx à l'interface utilisateur Web GoCD.

Option 2 : configuration du SSL natif de GoCD pour utiliser les certificats Let's Encrypt

Suivez cette section si vous souhaitez configurer le propre serveur Web de GoCD pour utiliser les certificats Let's Encrypt. Dans cette configuration, nous remplacerons le certificat auto-signé déjà utilisé par le serveur GoCD par un certificat de confiance fourni par Let's Encrypt. Pour ce faire, nous devrons convertir les fichiers de certificat dans un nouveau format et les importer dans un fichier de magasin de clés Java. Nous allons créer un script afin que le processus puisse être répété à chaque fois que les fichiers de certificat sont renouvelés.

Exigences supplémentaires

Si vous souhaitez gérer toutes les opérations SSL depuis GoCD lui-même, vous devrez télécharger un certificat depuis Let's Encrypt sans la procédure de configuration du serveur Web. Suivez ce guide pour télécharger le client approprié et obtenir un certificat pour votre domaine :

Une fois que vous avez terminé les guides ci-dessus, GoCD doit toujours être accessible à l'aide du certificat auto-signé en accédant à https://your_domain:8154 et les fichiers de certificat fournis par Let's Encrypt doivent être disponibles dans le répertoire /etc/letsencrypt/live/your_domain.

Création du script de conversion de certificat

GoCD utilise un Java keystore pour gérer les certificats SSL. Malheureusement, il s'agit d'un format différent de celui utilisé par Let's Encrypt. Pour utiliser nos certificats Let's Encrypt avec GoCD, nous devrons les convertir en suivant une procédure bien précise.

En raison de la complexité de la procédure et de notre besoin de convertir les certificats à chaque renouvellement, nous allons créer un script pour automatiser la procédure. Dans le répertoire /usr/local/bin, créez et ouvrez un script appelé convert_certs_for_gocd.sh dans votre éditeur de texte :

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

À l'intérieur, collez le script suivant. Le seul paramètre que vous devrez mettre à jour est la valeur de la variable base_domain. Définissez-le sur le nom de domaine de votre serveur GoCD (cela doit correspondre à la valeur du répertoire dans /etc/letsencrypt/live/) :

/usr/local/bin/convert_certs_for_gocd.sh

#!/bin/bash

base_domain="example.com"
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

Passons en revue exactement ce que fait ce script.

Au début, nous définissons quelques variables pour faciliter l'utilisation de notre script. Nous définissons le nom de domaine des certificats que nous voulons convertir et une variable qui se développe dans le répertoire des certificats Let's Encrypt. Nous créons un répertoire de travail temporaire avec la commande mktemp et attribuons la valeur à une autre variable. GoCD exige que tous ses mots de passe de keystore Java soient serverKeystorepa55w0rd, nous définissons une autre variable pour contenir cette valeur.

Ensuite, nous définissons une fonction qui supprime le répertoire temporaire lorsqu'elle est appelée. Nous l'utilisons à la fin de notre script pour nettoyer après nous-mêmes et aussi lorsque des erreurs inattendues se produisent. Pour accomplir cette deuxième possibilité, nous créons une autre fonction qui affiche un message d'erreur et nettoie avant de quitter. Nous utilisons la commande trap pour appeler cette fonction automatiquement chaque fois qu'une erreur est générée.

Ensuite, nous créons les fonctions qui effectuent la conversion proprement dite. La première fonction configure notre espace de travail en copiant la clé privée et le certificat de chaîne complète dans le répertoire de travail. La fonction convert_to_pkcs12 utilise openssl pour joindre le fichier de certificat de chaîne complète et le fichier de clé privée dans le fichier combiné PKCS 12 utilisé par l'outil de clé. Ce processus nécessite un mot de passe d'exportation, nous utilisons donc la variable de mot de passe GoCD.

La fonction suivante importe le nouveau fichier PKCS 12 dans un fichier keystore Java. Nous importons le fichier et fournissons le mot de passe d'exportation. Nous fournissons ensuite le même mot de passe pour les différents mots de passe du fichier keystore. Enfin, la dernière fonction copie le nouveau fichier keystore dans le répertoire /etc/go (après avoir sauvegardé l'ancien keystore), ajuste la propriété du fichier et redémarre le serveur GoCD.

À la fin du script, nous vérifions que le script est appelé avec les autorisations appropriées en vérifiant si l'ID utilisateur effectif est "0", ce qui signifie "avec les mêmes autorisations que root". Appelez ensuite les fonctions dans l'ordre approprié pour convertir correctement les certificats et installer le nouveau fichier keystore.

Lorsque vous avez terminé, enregistrez et fermez le fichier pour continuer.

Exécution de la conversion initiale

Maintenant que nous avons un script de conversion, nous devons l'utiliser pour effectuer la conversion initiale du certificat.

Tout d'abord, marquez le script comme exécutable afin qu'il puisse être exécuté directement sans appeler d'interpréteur :

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

Maintenant, appelez le script avec sudo pour effectuer la conversion initiale, installez le fichier keystore généré et redémarrez le processus GoCD

sudo /usr/local/bin/convert_certs_for_gocd.sh

Étant donné que le serveur GoCD doit redémarrer, le processus peut prendre un certain temps. Une fois le script terminé, cela peut prendre encore un moment ou deux avant que le serveur soit prêt à écouter les connexions. Vous pouvez voir les ports actuellement utilisés par les applications en tapant :

sudo watch netstat -plnt

Cette vue affichera les ports TCP sur lesquels les applications écoutent actuellement avec un taux de rafraîchissement de deux secondes. Lorsque GoCD commence à écouter les ports 8153 et 8154, l'écran devrait ressembler à ceci :

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 :::8153                 :::*                    LISTEN      8942/java
tcp6       0      0 :::8154                 :::*                    LISTEN      8942/java

Une fois que les ports 8153 et 8154 sont présents, appuyez sur CTRL-C pour quitter l'affichage.

Une fois que l'application commence à écouter les connexions, vérifiez l'interface Web en visitant votre domaine GoCD sur le port 8154 en utilisant HTTPS :

https://example.com:8154

Auparavant, lors de l'accès à cette page, une icône dans la barre d'adresse indiquait que le certificat n'était pas fiable (notez que l'indicateur visuel de votre navigateur peut être différent) :

Lors de votre première visite, vous avez probablement dû cliquer sur un écran d'avertissement dans votre navigateur :

Maintenant que nous avons remplacé le certificat auto-signé par un certificat de confiance fourni par Let's Encrypt, le navigateur indiquera que le certificat est de confiance et les utilisateurs n'auront pas à contourner un avertissement du navigateur pour accéder au site. Notez que le certificat précédent peut être mis en cache par votre navigateur jusqu'à ce que vous fermiez votre onglet, fenêtre ou session en cours :

Cela signifie que GoCD a pu utiliser le certificat Let's Encrypt que nous avons converti.

Configuration d'un crochet de renouvellement automatique

Maintenant que nous avons vérifié que notre script a correctement converti les actifs du certificat, nous pouvons nous assurer que certbot appelle notre script chaque fois que le certificat est renouvelé.

Ouvrez le fichier de configuration de renouvellement de votre domaine dans le répertoire /etc/letsencrypt/renewal en saisissant :

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

À l'intérieur, dans la section [renewalparams] du fichier, ajoutez un paramètre de ligne renew_hook à l'emplacement de votre script :

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

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

Le logiciel certbot installe une tâche cron qui vérifie si des certificats doivent être renouvelés deux fois par jour. Après le renouvellement d'un certificat, le script spécifié par renew_hook sera exécuté. De cette façon, nous pouvons nous assurer que GoCD utilise toujours le dernier certificat valide acquis auprès de Let's Encrypt.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vous pouvez vérifier que vous n'avez pas introduit d'erreurs de syntaxe dans le fichier en effectuant un essai à blanc de la procédure de renouvellement. Notez que cela n'exécutera pas notre script de conversion de certificat, mais qu'il imprimera un avis indiquant qu'il est ignoré :

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

-------------------------------------------------------------------------------
Processing /etc/letsencrypt/renewal/example.com.conf
-------------------------------------------------------------------------------
Cert not due for renewal, but simulating renewal for dry run
Renewing an existing certificate
Performing the following challenges:
http-01 challenge for example.com
Waiting for verification...
Cleaning up challenges
Dry run: skipping renewal hook command: /usr/local/bin/convert_certs_for_gocd.sh

-------------------------------------------------------------------------------
new certificate deployed without reload, fullchain is
/etc/letsencrypt/live/example.com/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/example.com/fullchain.pem (success)
** DRY RUN: simulating 'certbot renew' close to cert expiry
**          (The test certificates above have not been saved.)

La sortie ci-dessus vérifie que les modifications que nous avons apportées n'ont pas empêché le renouvellement du certificat. La sortie indique également que le hook de renouvellement pointe vers l'emplacement de script correct.

Conclusion

Dans ce guide, nous avons couvert deux manières différentes de sécuriser une installation GoCD avec un certificat SSL de confiance de Let's Encrypt. La première méthode a configuré le certificat avec Nginx, puis a redirigé le trafic vers l'interface Web de GoCD. La deuxième option a converti les fichiers de certificat Let's Encrypt au format PKCS 12 et les a importés dans un fichier de magasin de clés Java à utiliser par GoCD de manière native. Les deux options sécurisent l'interface Web de GoCD avec un certificat de confiance, mais elles y parviennent en utilisant différentes stratégies et avec des compromis uniques. L'approche qui vous convient dépendra en grande partie des besoins et des objectifs de votre équipe.