Utiliser Jenkins pour des builds distribués sur Compute Engine

---

Ce tutoriel vous explique comment :

• créer un système d'intégration continue Jenkins pour exécuter vos compilations à l'aide d'agents à la demande Jenkins dans Compute Engine ;
• stocker vos artefacts de compilation dans Cloud Storage ;
• appliquer une stratégie de cycle de vie pour déplacer des artefacts de compilation depuis Cloud Storage vers des solutions de stockage moins coûteuses.

Architecture

Le diagramme suivant présente l'architecture du tutoriel.

Comme vous pouvez le voir, un compte de service est ajouté à Jenkins afin de lui permettre de créer des instances d'agent et de transférer des artefacts vers Cloud Storage pour un stockage à long terme. Jenkins provisionne des instances à la volée au fur et à mesure de l'exécution des builds. Dans le même temps, les artefacts de build les plus anciens sont transférés dans différentes classes de stockage afin de limiter les coûts liés à leur conservation.

Objectifs

• Créer une image de base avec Packer pour exécuter vos compilations Jenkins
• Provisionner Jenkins à l'aide de Cloud Marketplace
• Configurer Jenkins pour déployer des agents de build éphémères
• Télécharger les artefacts de compilation dans Cloud Storage
• Configurer des stratégies du cycle de vie pour optimiser vos coûts Cloud Storage

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

• Compute Engine
• Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Utilisez le Simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Avant de commencer

1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Compute Engine API.

   Enable the API

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Compute Engine API.

   Enable the API

Configurer votre environnement

Dans cette section, vous allez configurer l'infrastructure et les identités requises pour effectuer le tutoriel. Pour le restant du tutoriel, vous allez travailler dans Cloud Shell.

Ouvrir Cloud Shell

Configurer IAM

Créez un compte de service Identity and Access Management (IAM) afin de transférer les autorisations vers Jenkins. Ce compte permet à Jenkins de stocker des données dans Cloud Storage et de lancer des instances dans Compute Engine. Une fois cette opération réalisée, Jenkins est en mesure d'exécuter vos builds dans des instances éphémères et de stocker les artefacts de build associés dans Cloud Storage.

Créer un compte de service

1. Créez le compte de service :

   gcloud iam service-accounts create jenkins --display-name jenkins

2. Stockez l'adresse e-mail du compte de service et votre ID de projet Google Cloud actuel dans des variables d'environnement pour pouvoir les utiliser ultérieurement avec vos commandes.

   export SA_EMAIL=$(gcloud iam service-accounts list \
       --filter="displayName:jenkins" --format='value(email)')
   export PROJECT=$(gcloud info --format='value(config.project)')

3. Associez les rôles suivants à votre compte de service :

   gcloud projects add-iam-policy-binding $PROJECT \
       --role roles/storage.admin --member serviceAccount:$SA_EMAIL
   gcloud projects add-iam-policy-binding $PROJECT --role roles/compute.instanceAdmin.v1 \
       --member serviceAccount:$SA_EMAIL
   gcloud projects add-iam-policy-binding $PROJECT --role roles/compute.networkAdmin \
       --member serviceAccount:$SA_EMAIL
   gcloud projects add-iam-policy-binding $PROJECT --role roles/compute.securityAdmin \
       --member serviceAccount:$SA_EMAIL
   gcloud projects add-iam-policy-binding $PROJECT --role roles/iam.serviceAccountActor \
       --member serviceAccount:$SA_EMAIL

Télécharger la clé du compte de service

Maintenant que vous avez accordé les autorisations appropriées au compte de service, vous devez créer et télécharger sa clé. Conservez celle-ci dans un lieu sûr. Vous allez l'utiliser plus tard lors de la configuration du plug-in JClouds afin qu'il puisse s'authentifier auprès de l'API Compute Engine.

Remarque : Les clés de compte de service constituent un risque pour la sécurité si elles ne sont pas gérées correctement. Dans la mesure du possible, vous devez choisir une alternative plus sécurisée aux clés de compte de service. Si vous devez vous authentifier avec une clé de compte de service, vous êtes responsable de la sécurité de la clé privée et des autres opérations décrites dans la section Bonnes pratiques pour la gestion des clés de compte de service. Si vous ne parvenez pas à créer une clé de compte de service, la création de clé de compte de service peut être désactivée pour votre organisation. Pour en savoir plus, consultez la page Gérer les ressources d'organisation sécurisées par défaut.

1. Créez le fichier de clé :

   gcloud iam service-accounts keys create jenkins-sa.json --iam-account $SA_EMAIL

2. Dans Cloud Shell, cliquez sur Plus , puis sur Télécharger le fichier.

3. Saisissez jenkins-sa.json.

4. Cliquez sur Télécharger pour enregistrer le fichier localement.

Créer une image d'agent Jenkins

Vous devez ensuite créer une image Compute Engine réutilisable contenant le logiciel et les outils nécessaires pour servir d'exécuteur Jenkins.

Créer une clé SSH pour Cloud Shell

Plus loin dans ce tutoriel, vous utiliserez Packer pour créer vos images, ce qui nécessite la commande ssh pour communiquer avec vos instances de compilation. Pour activer l'accès SSH, créez et importez une clé SSH dans Cloud Shell de la manière suivante :

1. Créez une paire de clés SSH. S'il en existe déjà une, la commande utilisera cette paire de clés. Sinon, elle en créera une :

   ls ~/.ssh/id_rsa.pub || ssh-keygen -N ""

2. Ajoutez la clé SSH publique Cloud Shell aux métadonnées de votre projet :

   gcloud compute project-info describe \
       --format=json | jq -r '.commonInstanceMetadata.items[] | select(.key == "ssh-keys") | .value' > sshKeys.pub
   echo "$USER:$(cat ~/.ssh/id_rsa.pub)" >> sshKeys.pub
   gcloud compute project-info add-metadata --metadata-from-file ssh-keys=sshKeys.pub

Créer l'image de base

L'étape suivante consiste à utiliser Packer pour créer une image de machine virtuelle (VM) de base pour vos agents de build, qui vont agir en tant qu'exécuteurs de builds éphémères dans Jenkins. Pour faire fonctionner les agents Jenkins de base, il suffit que Java soit installé. Vous pouvez personnaliser votre image en ajoutant des commandes d'interface système dans la section provisioners de la configuration Packer ou en ajoutant d'autres approvisionneurs Packer.

1. Dans Cloud Shell, téléchargez et décompressez la dernière version de Packer. L'exemple suivant utilise Packer 1.7.10. Vous pouvez consulter le site Web de HashiCorp pour voir s'il existe une version plus récente :

   wget https://releases.hashicorp.com/packer/1.7.10/packer_1.7.10_linux_amd64.zip
   unzip packer_1.7.10_linux_amd64.zip

2. Créez le fichier de configuration pour vos images de compilation Packer :

   export PROJECT=$(gcloud info --format='value(config.project)')
   cat > jenkins-agent.json <<EOF
   {
     "builders": [
       {
         "type": "googlecompute",
         "project_id": "$PROJECT",
         "source_image_family": "ubuntu-2004-lts",
         "source_image_project_id": "ubuntu-os-cloud",
         "zone": "us-central1-a",
         "disk_size": "50",
         "image_name": "jenkins-agent-{{timestamp}}",
         "image_family": "jenkins-agent",
         "ssh_username": "ubuntu"
       }
     ],
     "provisioners": [
       {
         "type": "shell",
         "inline": ["sudo apt-get update && sudo apt-get install -y default-jdk"]
       }
     ]
   }
   EOF
   

3. Créez l'image en exécutant Packer, comme suit :

   ./packer build jenkins-agent.json

   Une fois la compilation terminée, le nom de l'image disque est affiché au format jenkins-agent-[TIMESTAMP], où [TIMESTAMP] correspond à l'epoch de début de la compilation.

   ==> Builds finished. The artifacts of successful builds are:
   --> googlecompute: A disk image was created: jenkins-agent-1612997575
   

Installer Jenkins

Dans cette section, vous utiliserez Cloud Marketplace pour provisionner une instance Jenkins. Cette instance peut être personnalisée pour utiliser l'image de l'agent créée dans la section précédente.

1. Accédez à la solution Cloud Marketplace pour Jenkins.

2. Cliquez sur Lancement.

3. Définissez le champ Machine type (Type de machine) sur 4 vCPUs 15 GB Memory, n1-standard-4.

   

4. Cliquez sur Déployer et attendez que votre instance Jenkins soit totalement provisionnée. Une fois l'opération terminée, le message suivant s'affiche :

   

5. Ouvrez votre instance dans le navigateur en cliquant sur le lien Adresse du site.

6. Connectez-vous à Jenkins à l'aide des champs Admin user (Administrateur) et Admin password (Mot de passe administrateur) affichés dans le volet "Détails".

   

Votre instance Jenkins est maintenant prête à être utilisée.

Configurer des plug-ins Jenkins

Jenkins requiert des plug-ins pour créer des agents à la demande dans Compute Engine et stocker des artefacts dans Cloud Storage. Vous devez donc les installer et les configurer.

Installer des plug-ins

1. Dans l'interface utilisateur de Jenkins, sélectionnez Manage Jenkins (Gérer Jenkins).
2. Cliquez sur Manage Plugins (Gérer les plug-ins).
3. Cliquez sur l'onglet Available (Disponible).

4. Utilisez la barre Filter (Filtrer) pour rechercher les plug-ins suivants et cochez les cases correspondantes :

   • Plug-in Compute Engine
   • Plug-in Cloud Storage

   L'image suivante montre le plug-in Cloud Storage sélectionné :

   

5. Cliquez sur Download now and install after restart (Lancer le téléchargement et installer après redémarrage).

6. Cochez la case Restart Jenkins when installation is complete and no jobs are running (Redémarrer Jenkins lorsque l'installation est terminée et qu'aucune tâche n'est en cours d'exécution). Jenkins redémarre et termine l'installation des plug-ins sélectionnés.

Créer des identifiants de plug-in

Vous devez créer Google Credentials pour vos nouveaux plug-ins :

1. Connectez-vous à nouveau à Jenkins et cliquez sur Gérer Jenkins.
2. Cliquez sur Credentials (Identifiants).
3. Cliquez sur Jenkins sous Magasin.
4. Dans le volet principal de l'interface utilisateur, cliquez sur Global credentials (unrestricted) (Identifiants globaux (illimités)).

5. Créez les identifiants Google :

   1. Cliquez sur Add Credentials (Ajouter des identifiants).
   2. Définissez le champ Kind (Type) sur Google Service Account from private key (Compte de service Google à partir d'une clé privée).
   3. Dans le champ Project Name (Nom du projet), saisissez l'ID de votre projet Google Cloud.
   4. Cliquez sur Choose File (Sélectionner un fichier).
   5. Sélectionnez le fichier jenkins-sa.json que vous avez téléchargé précédemment depuis Cloud Shell.

   6. Cliquez sur OK.

      

6. Cliquez sur Jenkins.

Configurer le plug-in Compute Engine

Configurez le plug-in Compute Engine avec les mêmes identifiants que ceux utilisés pour provisionner vos instances d'agent.

1. Cliquez sur Manage Jenkins (Gérer Jenkins).
2. Cliquez sur Gérer les nœuds et les clouds.
3. Cliquez sur Configurer les clouds.
4. Cliquez sur Add a new cloud (Ajouter un nouveau cloud).
5. Cliquez sur Compute Engine.

6. Définissez les paramètres suivants et remplacez [YOUR_PROJECT_ID] par l'ID de votre projet Google Cloud :

   • Nom : gce
   • ID du projet : [YOUR_PROJECT_ID]
   • Instance Cap (Limite d'instances) : 8

7. Choisissez le compte de service approprié dans la liste déroulante Service Account Credentials (Identifiants de compte de service). Il est répertorié comme ID de votre projet Google Cloud.

Configurer les instances Jenkins

Maintenant que le plug-in Compute Engine est configuré, vous pouvez paramétrer les configurations d'instances Jenkins en fonction de vos besoins.

1. Sur la page Configurer les clouds, cliquez sur Ajouter pour Configurations d'instance.

2. Saisissez les paramètres Généraux suivants :

   • Nom : ubuntu-2004
   • Description : Ubuntu agent
   • Libellés : ubuntu-2004

3. Saisissez les informations suivantes pour les paramètres Emplacement :

   • Région : us-central1
   • Zone : us-central1-f

4. Cliquez sur Paramètres avancés.

5. Pour Machine Configuration (Configuration de la machine), choisissez le type de machine n1-standard-1.

6. Sous Networking (Mise en réseau), sélectionnez les paramètres suivants :

   • Network (Réseau) : conservez le paramètre par défaut.
   • Subnetwork (Sous-réseau) : conservez le paramètre par défaut.
   • Sélectionnez Attach External IP? (Associer une adresse IP externe ?).

7. Sélectionnez les informations suivantes pour les paramètres Boot Disk (Disque de démarrage) :

   • Dans le champ Image project (Projet d'image), choisissez votre projet Google Cloud.
   • Pour Image name (Nom de l'image), sélectionnez l'image que vous avez créée précédemment à l'aide de Packer.

8. Cliquez sur Save (Enregistrer) pour conserver vos modifications de configuration.

   

Créer une tâche Jenkins pour tester la configuration

Jenkins est configuré pour lancer automatiquement une instance lorsqu'une tâche nécessitant un agent avec le libellé ubuntu-2004 est déclenchée. Créez une tâche qui teste si la configuration fonctionne comme prévu.

1. Cliquez sur Create new job (Créer une tâche) dans l'interface Jenkins.
2. Saisissez test comme nom d'élément.
3. Cliquez sur Freestyle project (Projet libre), puis sur OK.
4. Cochez les cases Execute concurrent builds if necessary (Exécuter des compilations simultanées si nécessaire) et Restrict where this project can run (Limiter les emplacements d'exécution du projet).
5. Dans le champ Label Expression (Expression d'étiquette), saisissez ubuntu-2004.
6. Dans la section Build, cliquez sur Add build step (Ajouter une étape de build).
7. Cliquez sur Execute Shell (Exécuter Shell).

8. Dans la zone de commande, entrez une chaîne de test :

   echo "Hello world!"

   

9. Cliquez sur Save (Enregistrer).

10. Cliquez sur Build Now (Compiler maintenant) pour démarrer un build.

    

Importer des artefacts de compilation dans Cloud Storage

Vous pouvez avoir besoin de stocker des artefacts de compilation pour des analyses ou des tests futurs. Configurez vos tâches Jenkins afin de générer des artefacts et les transmettre à Cloud Storage. Le journal des builds est chargé dans le même bucket.

1. Dans Cloud Shell, créez un bucket de stockage pour vos artefacts :

   export PROJECT=$(gcloud info --format='value(config.project)')
   gcloud storage buckets create gs://$PROJECT-jenkins-artifacts

2. Dans la liste des tâches de l'interface utilisateur Jenkins, cliquez sur test (test).

3. Cliquez sur Configure (Configurer).

4. Sous Build, définissez le champ Command (Commande) sur :

   env > build_environment.txt

5. Sous Post-build Actions (Actions post-compilation), cliquez sur Add post-build action (Ajouter une action post-compilation).

6. Cliquez sur Cloud Storage Plugin (Plug-in Cloud Storage).

7. Dans le champ Storage Location (Emplacement de stockage), saisissez le chemin d'accès à l'artefact en remplaçant [YOUR_PROJECT_ID] par votre ID de projet Google Cloud :

   gs://[YOUR_PROJECT_ID]-jenkins-artifacts/$JOB_NAME/$BUILD_NUMBER

8. Cliquez sur Add Operation (Ajouter une opération).

9. Cliquez sur Classic Upload (Importation classique).

10. Dans le champ File Pattern (Règle de fichier), saisissez build_environment.txt.

11. Dans le champ Storage Location (Emplacement de stockage), saisissez votre chemin de stockage en remplaçant [YOUR_PROJECT_ID] par votre ID de projet Google Cloud :

    gs://[YOUR_PROJECT_ID]-jenkins-artifacts/$JOB_NAME/$BUILD_NUMBER

    

12. Cliquez sur Save (Enregistrer).

13. Cliquez sur Build Now (Compiler maintenant) pour démarrer une compilation. Celle-ci s'exécute sur l'instance Compute Engine que vous avez provisionnée précédemment. Une fois la compilation terminée, le fichier d'artefact build_environment.txt est importé dans le bucket Cloud Storage configuré.

14. Dans Cloud Shell, affichez l'artefact de compilation à l'aide de gcloud storage :

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud storage cat gs://$PROJECT-jenkins-artifacts/test/2/build_environment.txt

Configurer la gestion du cycle de vie des objets

Vous êtes plus susceptible d'accéder aux artefacts de compilation récents. Pour réduire les coûts liés au stockage d'objets rarement utilisés, mettez en œuvre une gestion du cycle de vie des objets afin de déplacer vos artefacts depuis les classes de stockage hautes performances vers des classes de stockage moins coûteuses et à latence élevée.

1. Dans Cloud Shell, créez le fichier de configuration du cycle de vie pour déplacer tous les objets vers un espace de stockage Nearline après 30 jours et tous les objets Nearline vers un espace de stockage Coldline après 365 jours.

   cat > artifact-lifecycle.json <<EOF
   {
   "lifecycle": {
     "rule": [
     {
       "action": {
         "type": "SetStorageClass",
         "storageClass": "NEARLINE"
       },
       "condition": {
         "age": 30,
         "matchesStorageClass": ["MULTI_REGIONAL", "STANDARD", "DURABLE_REDUCED_AVAILABILITY"]
       }
     },
     {
       "action": {
         "type": "SetStorageClass",
         "storageClass": "COLDLINE"
       },
       "condition": {
         "age": 365,
         "matchesStorageClass": ["NEARLINE"]
       }
     }
   ]
   }
   }
   EOF

2. Importez le fichier de configuration dans votre bucket de stockage d'artefacts :

   export PROJECT=$(gcloud info --format='value(config.project)')
   gcloud storage buckets update gs://$PROJECT-jenkins-artifacts --lifecycle-file=artifact-lifecycle.json

Nettoyer

1. Supprimez tous les agents Jenkins en cours d'exécution :

   gcloud compute instances list --filter=metadata.jclouds-group=ubuntu-2004 --uri | xargs gcloud compute instances delete

2. À l'aide de Cloud Deployment Manager, supprimez l'instance Jenkins :

   gcloud deployment-manager deployments delete jenkins-1

3. Supprimez le bucket Cloud Storage :

   export PROJECT=$(gcloud info --format='value(config.project)')
   gcloud storage rm gs://$PROJECT-jenkins-artifacts --recursive

4. Supprimez le compte de service :

   export SA_EMAIL=$(gcloud iam service-accounts list --filter="displayName:jenkins" --format='value(email)')
   gcloud iam service-accounts delete $SA_EMAIL

Étapes suivantes

• En savoir plus sur le déploiement continu à l'aide de Jenkins
• Déployez Jenkins sur Kubernetes Engine.
• Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.