Tutoriel : Créer un pipeline Jenkins à l’aide de GitHub et Docker

2025-05-08

Important

Bien que de nombreux services Azure disposent de plug-ins Jenkins, la plupart de ces plug-ins ont cessé d'être pris en charge à partir du 29 février 2024. Azure CLI est le moyen actuellement recommandé d’intégrer Jenkins aux services Azure. Pour plus d’informations, consultez l’article Sur les plug-ins Jenkins pour Azure.

Pour automatiser la phase de génération et de test du développement d’applications, vous pouvez utiliser un pipeline d’intégration et de déploiement continus (CI/CD). Dans ce tutoriel, vous allez créer un pipeline CI/CD sur une machine virtuelle Azure, notamment comment :

Créer une machine virtuelle Jenkins
Installer et configurer Jenkins
Créer une intégration de webhook entre GitHub et Jenkins
Créer et déclencher des tâches de build Jenkins à partir de commits GitHub
Créer une image Docker pour votre application
Vérifier que GitHub valide la génération d’une nouvelle image Docker et met à jour l’application en cours d’exécution

Ce tutoriel utilise l’interface CLI disponible dans Azure Cloud Shell, qui est constamment mise à jour vers la dernière version. Pour ouvrir Cloud Shell, sélectionnez Essayer en haut d’un bloc de code.

Si vous choisissez d’installer et d’utiliser l’interface de ligne de commande localement, ce didacticiel nécessite que vous exécutiez Azure CLI version 2.0.30 ou ultérieure. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.

Créer une instance Jenkins

Dans un tutoriel précédent sur la personnalisation d’une machine virtuelle Linux lors du premier démarrage, vous avez appris à automatiser la personnalisation des machines virtuelles avec cloud-init. Ce tutoriel utilise un fichier cloud-init pour installer Jenkins et Docker sur une machine virtuelle. Jenkins est un serveur d’automatisation open source populaire qui s’intègre en toute transparence à Azure pour permettre l’intégration continue (CI) et la livraison continue (CD). Pour plus de tutoriels sur l’utilisation de Jenkins, consultez Jenkins dans Azure Hub.

Dans votre interpréteur de commandes actuel, créez un fichier nommé cloud-init-jenkins.txt et collez la configuration suivante. Par exemple, créez le fichier dans l’interpréteur de commandes Cloud et non sur votre ordinateur local. Entrez sensible-editor cloud-init-jenkins.txt pour créer le fichier et voir la liste des éditeurs disponibles. Vérifiez que l’intégralité du fichier cloud-init est copiée, en particulier la première ligne :

#cloud-config
package_upgrade: true
write_files:
  - path: /etc/systemd/system/docker.service.d/docker.conf
    content: |
      [Service]
        ExecStart=
        ExecStart=/usr/bin/dockerd
  - path: /etc/docker/daemon.json
    content: |
      {
        "hosts": ["fd://","tcp://127.0.0.1:2375"]
      }
runcmd:
  - apt install openjdk-8-jre-headless -y
  - wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -
  - sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
  - apt-get update && apt-get install jenkins -y
  - curl -sSL https://get.docker.com/ | sh
  - usermod -aG docker azureuser
  - usermod -aG docker jenkins
  - service jenkins restart

Pour pouvoir créer une machine virtuelle, vous devez créer un groupe de ressources avec la commande az group create. L’exemple suivant crée un groupe de ressources nommé myResourceGroupJenkins à l’emplacement eastus :

az group create --name myResourceGroupJenkins --location eastus

Créez maintenant une machine virtuelle avec la commande az vm create. Utilisez le paramètre --custom-data à transmettre dans votre fichier de configuration cloud-init. Indiquez le chemin complet de cloud-init-jenkins.txt si vous avez enregistré le fichier en dehors de votre répertoire de travail actuel.

az vm create --resource-group myResourceGroupJenkins \
    --name myVM \
    --image UbuntuLTS \
    --admin-username azureuser \
    --generate-ssh-keys \
    --custom-data cloud-init-jenkins.txt

La création et la configuration de la machine virtuelle prennent quelques minutes.

Pour autoriser le trafic web à atteindre votre machine virtuelle, utilisez az vm open-port pour ouvrir le port 8080 pour le trafic Jenkins et le port 1337 pour l’application Node.js utilisée pour exécuter un exemple d’application :

az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 8080 --priority 1001
az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 1337 --priority 1002

Configurer Jenkins

Pour accéder à votre instance Jenkins, obtenez l’adresse IP publique de votre machine virtuelle :

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

À des fins de sécurité, vous devez entrer le mot de passe d’administrateur initial stocké dans un fichier texte sur votre machine virtuelle pour démarrer l’installation Jenkins. Utilisez l’adresse IP publique obtenue à l’étape précédente pour ssh sur votre machine virtuelle :

ssh azureuser@<publicIps>

Vérifiez que Jenkins est en cours d’exécution à l’aide de la service commande :

$ service jenkins status
● jenkins.service - LSB: Start Jenkins at boot time
   Loaded: loaded (/etc/init.d/jenkins; generated)
   Active: active (exited) since Tue 2019-02-12 16:16:11 UTC; 55s ago
     Docs: man:systemd-sysv-generator(8)
    Tasks: 0 (limit: 4103)
   CGroup: /system.slice/jenkins.service

Feb 12 16:16:10 myVM systemd[1]: Starting LSB: Start Jenkins at boot time...
...

Affichez le initialAdminPassword de votre installation Jenkins et copiez-le :

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Si le fichier n’est pas encore disponible, attendez quelques minutes supplémentaires pour que cloud-init termine l’installation jenkins et Docker.

Ouvrez maintenant un navigateur web et accédez à http://<publicIps>:8080. Terminez la configuration initiale de Jenkins comme suit :

Choisir sélectionner des plug-ins à installer
Recherchez GitHub dans la zone de texte en haut. Cochez la case pour GitHub, puis sélectionnez Installer
Créez le premier utilisateur administrateur. Entrez un nom d’utilisateur, tel que l’administrateur, puis fournissez votre propre mot de passe sécurisé. Enfin, tapez un nom complet et une adresse de messagerie.
Sélectionner Enregistrer et terminer
Une fois Jenkins prêt, sélectionnez Démarrer à l’aide de Jenkins
- Si votre navigateur web affiche une page vide lorsque vous commencez à utiliser Jenkins, redémarrez le service Jenkins. À partir de votre session SSH, tapez sudo service jenkins restart, puis actualisez votre navigateur web.
Si nécessaire, connectez-vous à Jenkins avec le nom d’utilisateur et le mot de passe que vous avez créés.

Créer un webhook GitHub

Pour configurer l’intégration à GitHub, ouvrez l’exemple d’applicationNode.js Hello World à partir du référentiel d’exemples Azure. Pour dupliquer le dépôt sur votre propre compte GitHub, sélectionnez le bouton Dupliquer dans le coin supérieur droit.

Créez un webhook à l’intérieur du fork que vous avez créé :

Sélectionnez Paramètres, puis sélectionnez Webhooks sur le côté gauche.
Choisissez Ajouter un webhook, puis entrez Jenkins dans la zone de filtre.
Pour l’URL de la charge utile, entrez http://<publicIps>:8080/github-webhook/. Assurez-vous d’inclure la barre oblique finale.
Pour le type de contenu, sélectionnez application/x-www-form-urlencoded.
Pour quels événements souhaitez-vous déclencher ce webhook ?, sélectionnez Simplement l’événement Push.
Définissez Actif sur activé.
Cliquez sur Ajouter un webhook.

Ajouter un webhook GitHub à votre dépôt forked

Créer une tâche Jenkins

Pour que Jenkins réponde à un événement dans GitHub, comme la validation du code, créez un travail Jenkins. Utilisez les URL de votre propre réplique GitHub.

Dans votre site web Jenkins, sélectionnez Créer des travaux dans la page d’accueil :

Entrez HelloWorld comme nom de travail. Choisissez Le projet Freestyle, puis sélectionnez OK.
Sous la section Général , sélectionnez le projet GitHub et entrez votre URL de dépôt forked, par exemple https://github.com/cynthn/nodejs-docs-hello-world
Dans la section Gestion du code source , sélectionnez Git, entrez votre URL .git de dépôt forked, par exemple https://github.com/cynthn/nodejs-docs-hello-world.git
Dans la section Déclencheurs de build, sélectionnez le déclencheur de hook GitHub pour le sondage GitSCM.
Sous la section Build , choisissez Ajouter une étape de génération. Sélectionnez Exécuter l’interpréteur de commandes, puis entrez echo "Test" dans la fenêtre de commande.
Sélectionnez Enregistrer en bas de la fenêtre travaux.

Tester l’intégration de GitHub

Pour tester l’intégration de GitHub à Jenkins, faites un commit dans votre fork.

De retour dans l’interface utilisateur web GitHub, sélectionnez votre dépôt dupliqué, puis sélectionnez le fichier index.js . Sélectionnez l’icône de crayon pour modifier ce fichier afin que la ligne 6 lit :

response.end("Hello World!");

Pour valider vos modifications, sélectionnez le bouton Valider les modifications en bas.

Dans Jenkins, une nouvelle build démarre sous la section Historique des builds du coin inférieur gauche de votre page de travail. Choisissez le lien du numéro de build et sélectionnez La sortie de la console sur le côté gauche. Vous pouvez afficher les étapes que Jenkins prend lorsque votre code est extrait de GitHub et que l’action de génération génère le message Test dans la console. Chaque fois qu’une validation est effectuée dans GitHub, le webhook atteint Jenkins et déclenche une nouvelle build de cette façon.

Définir l’image de build Docker

Pour voir tourner l'application Node.js à partir de vos commits GitHub, créons une image Docker pour l'exécuter. L’image est générée à partir d’un fichier Dockerfile qui définit comment configurer le conteneur qui exécute l’application.

À partir de la connexion SSH à votre machine virtuelle, accédez au répertoire de l’espace de travail Jenkins nommé après le travail que vous avez créé à l’étape précédente. Dans cet exemple, qui a été nommé HelloWorld.

cd /var/lib/jenkins/workspace/HelloWorld

Créez un fichier dans ce répertoire d’espace de travail avec sudo sensible-editor Dockerfile et collez le contenu suivant. Assurez-vous que l’intégralité du fichier Dockerfile est copiée correctement, en particulier la première ligne :

FROM node:alpine

EXPOSE 1337

WORKDIR /var/www
COPY package.json /var/www/
RUN npm install
COPY index.js /var/www/

Ce fichier Dockerfile utilise l’image de base Node.js à l’aide d’Alpine Linux, expose le port 1337 sur lequel l’application Hello World s’exécute, puis copie les fichiers d’application et l’initialise.

Créer des règles de génération Jenkins

À l’étape précédente, vous avez créé une règle de build Jenkins de base qui génère un message dans la console. Créons l’étape de construction pour utiliser notre Dockerfile et exécuter l’application.

De retour dans votre instance Jenkins, sélectionnez le travail que vous avez créé à l’étape précédente. Sélectionnez Configurer sur le côté gauche et faites défiler vers le bas jusqu’à la section Build :

Supprimez votre étape de compilation existante echo "Test". Sélectionnez la croix rouge en haut à droite de la zone d’étape de build existante.
Choisissez Ajouter une étape de génération, puis sélectionnez Exécuter l’interpréteur de commandes

Dans la zone Commande , entrez les commandes Docker suivantes, puis sélectionnez Enregistrer :

docker build --tag helloworld:$BUILD_NUMBER .
docker stop helloworld && docker rm helloworld
docker run --name helloworld -p 1337:1337 helloworld:$BUILD_NUMBER node /var/www/index.js &

Les étapes de génération Docker créent une image et l’étiquetent avec le numéro de build Jenkins pour que vous puissiez conserver un historique des images. Tous les conteneurs existants exécutant l’application sont arrêtés, puis supprimés. Un nouveau conteneur est ensuite démarré à l’aide de l’image et exécute votre application Node.js en fonction des validations les plus récentes dans GitHub.

Testez votre pipeline

Pour afficher l’ensemble du pipeline en action, modifiez à nouveau le fichier index.js dans votre dépôt GitHub forked, puis sélectionnez Valider la modification. Un nouveau travail démarre dans Jenkins en fonction du webhook pour GitHub. La création de l’image Docker et le démarrage de votre application dans un nouveau conteneur prend quelques secondes.

Si nécessaire, obtenez à nouveau l’adresse IP publique de votre machine virtuelle :

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Ouvrez un navigateur web et entrez http://<publicIps>:1337. Votre application Node.js s’affiche et reflète les validations les plus récentes dans votre fork GitHub comme suit :

Exécution d’une application Node.js

Apportez maintenant une autre modification au fichier index.js dans GitHub et validez la modification. Attendez quelques secondes pour que le travail se termine dans Jenkins, puis actualisez votre navigateur web pour voir la version mise à jour de votre application s’exécutant dans un nouveau conteneur comme suit :

Exécution d’une application Node.js après une autre validation GitHub

Étapes suivantes

Dans ce tutoriel, vous avez configuré GitHub pour exécuter un travail de génération Jenkins sur chaque validation de code, puis déployer un conteneur Docker pour tester votre application. Vous avez appris à :

Créer une machine virtuelle Jenkins
Installer et configurer Jenkins
Créer une intégration de webhook entre GitHub et Jenkins
Créer et déclencher des tâches de build Jenkins à partir de commits GitHub
Créer une image Docker pour votre application
Vérifier que GitHub valide la génération d’une nouvelle image Docker et met à jour l’application en cours d’exécution

Passez au tutoriel suivant pour en savoir plus sur l’intégration de Jenkins à Azure DevOps Services.

Déployer des applications avec Jenkins et Azure DevOps Services