Tutoriel : Déployer sur Azure Kubernetes Service à partir de GitHub avec Jenkins
Important
De nombreux services Azure disposent de plug-ins Jenkins. Certains de ces plug-ins ne seront plus pris en charge à partir du 29 février 2024. Azure CLI est la méthode actuellement recommandée pour intégrer Jenkins à des services Azure. Pour plus d’informations, reportez-vous à l’article Plug-ins Jenkins pour Azure.
Ce tutoriel explique comment déployer un exemple d’application de GitHub sur un cluster Azure Kubernetes Service (AKS) en configurant l’intégration continue (CI) et le déploiement continu (CD) dans Jenkins.
Dans ce tutoriel, vous allez effectuer les tâches suivantes :
- Déployer un exemple d’application de vote Azure sur un cluster AKS
- Créer un projet de base Jenkins
- Configurer les informations d’identification pour Jenkins afin d’interagir avec ACR
- Créer un travail de build Jenkins et un webhook GitHub pour les builds automatisées
- Tester le pipeline CI/CD pour mettre à jour une application dans AKS en fonction des validations de code GitHub
Prérequis
Pour les besoins de ce tutoriel, vous devez disposer des éléments suivants :
Notions de base de Kubernetes, Git, CI/CD et images conteneur
Un cluster AKS et
kubectlconfiguré avec les informations d’identification du cluster AKS.Un registre Azure Container Registry (ACR), le nom du serveur de connexion ACR et le cluster AKS configuré pour s’authentifier auprès du registre ACR.
Un contrôleur Jenkins déployé sur une machine virtuelle Azure.
Azure CLI version 2.0.46 ou ultérieure installé et configuré. Exécutez
az --versionpour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.Docker installé sur votre système de développement
Un compte GitHub, un jeton d’accès personnel GitHub et un client Git installé sur votre système de développement
Si vous fournissez votre propre instance Jenkins à la place de cet exemple de façon scriptée de déployer Jenkins, votre instance Jenkins a besoin de Docker installé et configuré et de kubectl.
Préparation de votre application
Dans cet article, vous allez utiliser un exemple d’application de vote Azure qui contient une interface web et Redis pour le stockage de données temporaires.
Avant d’intégrer Jenkins et AKS pour les déploiements automatisés, préparez et déployez d’abord manuellement l’application de vote Azure sur votre cluster AKS. Ce déploiement manuel vous permet de voir l’application en action.
Remarque
L’exemple d’application de vote Azure utilise un pod Linux programmé pour s’exécuter sur un nœud Linux. Le flux décrit dans cet article fonctionne également pour un pod Windows Server programmé sur un nœud Windows Server.
Dupliquez le référentiel GitHub suivant pour l’exemple d’application : https://github.com/Azure-Samples/azure-voting-app-redis. Pour répliquer le référentiel dans votre propre compte GitHub, cliquez sur le bouton Bifurcation en haut à droite.
Clonez la duplication sur votre système de développement. Assurez-vous d’utiliser l’URL de votre branche lorsque vous clonez le référentiel :
git clone https://github.com/<your-github-account>/azure-voting-app-redis.git
Accédez au répertoire de votre duplication clonée :
cd azure-voting-app-redis
Pour créer les images conteneur nécessaires à l’exemple d’application, utilisez le fichier docker-compose.yaml avec docker-compose :
docker-compose up -d
Les images de base nécessaires sont extraites et les conteneurs d’applications sont générés. Vous pouvez ensuite utiliser la commande docker images pour afficher l’image créée. Trois images ont été téléchargées ou créées. L’image azure-vote-front contient l’application et utilise l’image nginx-flask comme base. L’image redis est utilisée pour démarrer une instance Redis :
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
azure-vote-front latest 9cc914e25834 40 seconds ago 694MB
redis latest a1b99da73d05 7 days ago 106MB
tiangolo/uwsgi-nginx-flask flask 788ca94b2313 9 months ago 694MB
Connectez-vous à votre registre de conteneurs Azure Container Registry.
az acr login -n <acrLoginServer>
Remplacez <acrLoginServer> par votre serveur de connexion ACR.
Utilisez la commande docker tag pour baliser l’image avec le nom du serveur de connexion ACR et le nombre de version v1. Utilisez le nom de votre propre <acrLoginServer> obtenu à l’étape précédente :
docker tag azure-vote-front <acrLoginServer>/azure-vote-front:v1
Enfin, envoyez l’image azure-vote-front à votre registre ACR. Là encore, remplacez <acrLoginServer> par le nom du serveur de connexion de votre propre registre ACR, tel que myacrregistry.azurecr.io :
docker push <acrLoginServer>/azure-vote-front:v1
Déployer l’exemple d’application sur AKS
Pour déployer l’exemple d’application sur votre cluster AKS, vous pouvez utiliser le fichier manifeste Kubernetes à la racine du référentiel de vote Azure. Ouvrez le fichier manifeste azure-vote-all-in-one-redis.yaml avec un éditeur tel que vi. Remplacez microsoft par le nom de votre serveur de connexion ACR. Cette valeur se trouve à la ligne 60 du fichier manifeste :
containers:
- name: azure-vote-front
image: azuredocs/azure-vote-front
Utilisez ensuite la commande kubectl apply pour déployer l’application sur votre cluster AKS :
kubectl apply -f azure-vote-all-in-one-redis.yaml
Un service d’équilibreur de charge Kubernetes est créé pour exposer l’application sur Internet. Ce processus peut prendre quelques minutes. Pour surveiller la progression du déploiement de l’équilibreur de charge, utilisez la commande kubectl get service avec l’argument --watch.
$ kubectl get service azure-vote-front --watch
Une fois que l’adresse EXTERNAL-IP est passée du statut En attente à Adresse IP, utilisez Control + C pour arrêter le processus de surveillance kubectl.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
Pour voir l’application en action, ouvrez un navigateur web en utilisant l’adresse IP externe de votre service. L’application de vote Azure apparaît telle que dans l’exemple suivant :
Configurer le contrôleur Jenkins
Appliquez les modifications suivantes pour permettre les déploiements AKS à partir du contrôleur Jenkins :
Ouvrez le port 80 entrant.
az vm open-port \
--resource-group <Resource_Group_name> \
--name <Jenkins_Controller_VM> \
--port 80 --priority 1020
Remplacez <Resource_Group_name> et <Jenkins_Controller_VM> par les valeurs appropriées.
SSH dans le contrôleur Jenkins
ssh azureuser@<PublicIPAddress>
Remplacez <PublicIPAddress> par l’adresse IP du contrôleur Jenkins.
Installer AzCLI et s’y connecter
curl -L https://aka.ms/InstallAzureCli | bash
az login
Remarque
Pour installer manuellement AzCLI, suivez ces instructions.
Installation de Docker
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y;
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -;
sudo apt-key fingerprint 0EBFCD88;
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable";
sudo apt-get update;
sudo apt-get install docker-ce -y;
Installer Kubectl et se connecter à AKS
sudo az aks install-cli
sudo az aks get-credentials --resource-group <Resource_Group> --name <AKS_Name>
Remplacez <Resource_Group> et <AKS_Name> par les valeurs appropriées.
Configurer l’accès
sudo usermod -aG docker jenkins;
sudo usermod -aG docker azureuser;
sudo touch /var/lib/jenkins/jenkins.install.InstallUtil.lastExecVersion;
sudo service jenkins restart;
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chmod 777 /var/lib/jenkins/
sudo chmod 777 /var/lib/jenkins/config
Créer une variable d’environnement Jenkins
Une variable d’environnement Jenkins est utilisée pour contenir le nom du serveur de connexion ACR. Cette variable est référencée lors du travail de build Jenkins. Pour créer cette variable d’environnement, procédez comme suit :
À gauche du portail Jenkins, sélectionnez Gérer Jenkins>Configurer le système
Sous Propriétés globales, sélectionnez Variables d’environnement. Ajoutez une variable nommée
ACR_LOGINSERVERet la valeur de votre serveur de connexion ACR.
Quand vous avez terminé, sélectionnez Enregistrer au bas de la page.
Créer des informations d’identification Jenkins pour ACR
Pendant le processus CI/CD, Jenkins génère de nouvelles images conteneur basées sur les mises à jour de l’application. Il doit ensuite envoyer ces images au registre ACR.
Pour autoriser Jenkins à pousser des images conteneur mises à jour vers ACR, vous devez spécifier les informations d’identification pour ACR.
Pour une séparation des rôles et des autorisations, configurez un principal de service pour Jenkins avec des autorisations Contributeur sur votre registre ACR.
Créer un principal du service pour que Jenkins puisse utiliser ACR
Créez tout d’abord un principal du service à l’aide de la commande az ad sp create-for-rbac :
az ad sp create-for-rbac
Cette commande produit une sortie semblable à celle de l’exemple suivant :
{
"appId": "<app-ID>",
"displayName": "azure-cli-2018-09-28-22-19-34",
"name": "http://azure-cli-2018-09-28-22-19-34",
"password": "<password>",
"tenant": "<tenant-ID>"
}
Prenez note des valeurs de appId et de password. Ces valeurs sont utilisées dans les étapes suivantes pour configurer la ressource d’informations d’identification dans Jenkins.
Obtenez l’ID de ressource de votre registre ACR à l’aide de la commande az acr show et stockez-le en tant que variable.
ACR_ID=$(az acr show --resource-group <Resource_Group> --name <acrLoginServer> --query "id" --output tsv)
Remplacez <Resource_Group> et <acrLoginServer> par les valeurs appropriées.
Créez une attribution de rôle pour assigner au principal du service des droits Contributeur sur le registre ACR.
az role assignment create --assignee <appID> --role Contributor --scope $ACR_ID
Remplacez <appId> par la valeur fournie dans la sortie de la commande précédente ayant servi à créer le principal du service.
Créer une ressource d’informations d’identification dans Jenkins pour le principal du service ACR
Avec l’attribution de rôle créée dans Azure, stockez maintenant vos informations d’identification ACR dans un objet d’identification Jenkins. Ces informations d’identification sont référencées lors de la tâche de génération Jenkins.
De retour dans la partie gauche du portail Jenkins, sélectionnez Manage Jenkins (Gérer Jenkins)>Manage Credentials (Gérer les informations d’identification)>Jenkins Store (Magasin Jenkins)>Global credentials (Unrestricted) [Informations d’identification (sans restriction)]>Add Credentials (Ajouter des informations d’identification)
Assurez-vous que le genre d’informations d’identification correspond à Mot de passe avec nom d’utilisateur puis entrez les informations suivantes :
- Nom d’utilisateur : appId du principal de service créé pour s’authentifier auprès de votre registre ACR.
- Mot de passe : password du principal de service créé pour s’authentifier auprès de votre registre ACR.
- ID : identificateur d’informations d’identification, tel que acr-credentials
Lorsque vous avez terminé, le formulaire d’informations d’identification ressemble à l’exemple suivant :
Sélectionnez OK et revenez au portail Jenkins.
Créer un projet Jenkins
Dans la page d’accueil de votre portail Jenkins, sélectionnez Nouvel élément à gauche :
Entrez azure-vote comme nom du travail. Choisissez Projet libre, puis sélectionnez OK
Dans la section Général, sélectionnez Projet GitHub puis entrez l’URL de votre dépôt dupliqué, par exemple https://github.com/<votre-compte-github>/azure-voting-app-redis
Dans la section Gestion du code source, sélectionnez Git, puis entrez l’URL
.gitde votre dépôt dupliqué, par exemple https://github.com/<votre-compte-github>/azure-voting-app-redis.gitDans la section Déclencheurs de génération, sélectionnez Déclencher un hook GitHub pour l’interrogation GITScm
Sous Environnement de build, sélectionnez Utiliser des textes ou fichiers secrets
Sous Liaisons, sélectionnez Ajouter>Nom d’utilisateur et mot de passe (distincts)
Entrez
ACR_IDcomme Variable de nom d’utilisateur, etACR_PASSWORDcomme Variable de mot de passe
Choisissez d’ajouter une Étape de génération de type Exécuter un script shell et utilisez le texte suivant. Ce script génère une image conteneur et l’envoie dans votre registre ACR.
# Build new image and push to ACR. WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}" docker build -t $WEB_IMAGE_NAME ./azure-vote docker login ${ACR_LOGINSERVER} -u ${ACR_ID} -p ${ACR_PASSWORD} docker push $WEB_IMAGE_NAMEAjoutez une autre Étape de génération de type Exécuter un script shell et utilisez le texte suivant. Ce script met à jour le déploiement d’application dans AKS avec la nouvelle image conteneur d’ACR.
# Update kubernetes deployment with new image. WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}" kubectl set image deployment/azure-vote-front azure-vote-front=$WEB_IMAGE_NAMEUne fois terminé, cliquez sur Enregistrer.
Tester la build Jenkins
Avant d’automatiser le travail en fonction des commits GitHub, testez manuellement la build Jenkins.
Cette build vérifie que le travail a été correctement configuré. Elle confirme que le fichier d’authentification Kubernetes approprié est en place et que l’authentification auprès d’ACR fonctionne.
Dans le menu de gauche du projet, sélectionnez Générer maintenant.
La première build prend plus de temps, car les couches d’image Docker sont extraites vers le serveur Jenkins.
Les builds :
- Clonent le dépôt GitHub
- Génèrent une nouvelle image conteneur
- Poussent l’image conteneur vers le registre ACR
- Mettent à jour l’image utilisée par le déploiement AKS
L’interface utilisateur web est inchangée, car aucune modification n’a été apportée au code de l’application.
Une fois le travail de build terminé, sélectionnez build #1 sous l’historique de build. Sélectionnez Sortie de console et affichez la sortie du processus de génération. La dernière ligne doit indiquer que la génération a été un succès.
Créer un webhook GitHub
Lorsque la build manuelle est terminée, intégrez GitHub à la build Jenkins. Utilisez un webhook pour exécuter le travail de build Jenkins chaque fois que le code est commité sur GitHub.
Pour créer le webhook GitHub, procédez comme suit :
Accédez à votre référentiel GitHub dupliqué dans un navigateur web.
Sélectionnez Paramètres, puis Webhooks sur le côté gauche.
Choisissez d’Ajouter un webhook. Pour la Charge utile de l’URL, entrez
http://<publicIp:8080>/github-webhook/, où<publicIp>correspond à l’adresse IP du serveur Jenkins. Veillez à inclure la barre oblique/à la fin. Laissez les autres paramètres par défaut pour le type de contenu et pour le déclencheur d'événements Push.Sélectionnez Ajouter un webhook.
Test l’ensemble du pipeline CI/CD
Vous pouvez maintenant tester l’ensemble du pipeline CI/CD. Lorsque vous envoyez une validation de code à GitHub, les étapes suivantes se produisent :
- Le webhook GitHub notifie Jenkins.
- Jenkins démarre le travail de build et extrait la dernière validation de code de GitHub.
- Une build Docker est démarrée en utilisant le code mis à jour, et la nouvelle image conteneur est marquée avec le dernier numéro de build.
- Cette nouvelle image conteneur est envoyée à Azure Container Registry.
- Votre application s’exécutant dans Azure Kubernetes Service est mise à jour avec la dernière image d’Azure Container Registry.
Sur votre machine de développement, ouvrez l’application clonée avec un éditeur de code. Sous le répertoire /azure-vote/azure-vote, ouvrez le fichier nommé config_file.cfg. Mettez à jour les valeurs de vote dans ce fichier en quelque chose différent de chats et chiens, comme indiqué dans l’exemple suivant :
# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Blue'
VOTE2VALUE = 'Purple'
SHOWHOST = 'false'
Une fois la mise à jour terminée, enregistrez le fichier, commitez les modifications, puis poussez-les vers votre duplication (fork) du dépôt GitHub. Le webhook GitHub déclenche un nouveau travail de build dans Jenkins. Dans le tableau de bord Jenkins, surveillez le processus de génération. Il ne faut que quelques secondes pour extraire le dernier code, créer et envoyer l’image mise à jour, et pour déployer l’application mise à jour sur AKS.
Une fois la build terminée, actualisez votre navigateur web de l’exemple d’application de vote Azure. Vos modifications apparaissent, comme dans l’exemple suivant :
