Tutoriel : Déployer sur Azure App Service avec Jenkins et Azure CLI

Article
05/30/2023

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.

Pour déployer une application web Java sur Azure, vous pouvez utiliser Azure CLI dans un pipeline Jenkins. Dans ce tutoriel, vous allez effectuer les tâches suivantes :

Créer une machine virtuelle Jenkins
Configurer Jenkins
Créer une application web dans Azure
Préparer un dépôt GitHub
Créer un pipeline Jenkins
Exécuter le pipeline et vérifier l’application web

Prérequis

Abonnement Azure : Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Jenkins - Installer Jenkins sur une machine virtuelle Linux
Azure CLI : Installez Azure CLI (version 2.0.67 ou ultérieure) sur le serveur Jenkins.

Configurer Jenkins

Les étapes suivantes montrent comment installer le JDK Java nécessaire et Maven sur le contrôleur Jenkins :

Connectez-vous au contrôleur Jenkins avec SSH.

Téléchargez et installez la build Azul Zulu d’OpenJDK pour Azure à partir d’un référentiel apt-get :

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 0xB1998361219BD9C9
sudo apt-add-repository "deb http://repos.azul.com/azure-only/zulu/apt stable main"
sudo apt-get -q update
sudo apt-get -y install zulu-8-azure-jdk

Exécutez la commande suivante pour installer Maven :
```
sudo apt-get install -y maven
```

Ajouter le principal de service Azure aux informations d’identification Jenkins

Les étapes suivantes montrent comment spécifier vos informations d’identification Azure :

Vérifiez que le plug-in Credentials est installé.
Dans le tableau de bord Jenkins, sélectionnez Informations d’identification -> Système ->.
Sélectionnez Global credentials(unrestricted) (Informations d’identification globales (sans restriction)).
Sélectionnez Add Credentials (Ajouter des informations d’identification) pour ajouter un principal de service Microsoft Azure. Vérifiez que le genre d’informations d’identification correspond à Username with password (Nom d’utilisateur et mot de passe) et entrez les éléments suivants :
- Username (Nom d’utilisateur) : appId du principal de service
- Mot de passe : principal du service password
- ID : Identificateur d’informations d’identification (par AzureServicePrincipalexemple)

Créer un plan Azure App Service pour déployer l’application web Java

Utilisez az appservice plan create pour créer un plan Azure App Service avec le niveau tarifaire GRATUIT :

az appservice plan create \
    --name <app_service_plan> \ 
    --resource-group <resource_group> \
    --sku FREE

Points essentiels :

Le plan App Service définit les ressources physiques utilisées pour héberger vos applications.
Toutes les applications affectées à un plan App Service partagent ces ressources.
Les plans App Service vous permettent de réduire les coûts d’hébergement de plusieurs applications.

Créer une application web Azure

Utilisez az webapp create pour créer une définition d’application web dans le plan App Service myAppServicePlan.

az webapp create \
    --name <app_name> \ 
    --resource-group <resource_group> \
    --plan <app_service_plan>

Points essentiels :

La définition d’application web fournit une URL pour accéder à votre application et permet de configurer plusieurs options pour déployer votre code dans Azure.
Remplacez l’espace réservé <app_name> par un nom d’application unique.
Le nom de l’application fait partie du nom de domaine par défaut de l’application web. Il doit donc être unique parmi ceux de toutes les applications dans Azure.
Vous pouvez mapper une entrée de nom de domaine personnalisée vers l’application web avant de l’exposer à vos utilisateurs.

Configurer Java

Utilisez az appservice web config update pour définir la configuration du runtime Java pour l’application :

az webapp config set \ 
    --name <app_name> \
    --resource-group <resource_group> \ 
    --java-version 1.8 \ 
    --java-container Tomcat \
    --java-container-version 8.0

Préparer un dépôt GitHub

Ouvrez le dépôt Application web Java simple pour Azure.
Sélectionnez le bouton Fork (Duplication (fork)) pour dupliquer (fork) le dépôt sur votre propre compte GitHub.
Ouvrez le fichier Jenkinsfile en cliquant sur le nom du fichier.
Sélectionnez l’icône en forme de crayon pour modifier le fichier.

Mettez à jour l’ID d’abonnement et l’ID de locataire.

  withEnv(['AZURE_SUBSCRIPTION_ID=<subscription_id>',
        'AZURE_TENANT_ID=<tenant_id>'])

Mettez à jour le groupe de ressources et le nom de votre application web, respectivement les lignes 22 et 23.
```
def resourceGroup = '<resource_group>'
def webAppName = '<app_name>'
```

Mettez à jour l’ID des informations d’identification dans votre instance de Jenkins.

withCredentials([usernamePassword(credentialsId: '<service_princial>', passwordVariable: 'AZURE_CLIENT_SECRET', usernameVariable: 'AZURE_CLIENT_ID')]) {

Créer un pipeline Jenkins

Pour créer un pipeline Jenkins, effectuez les étapes suivantes :

Ouvrez Jenkins dans un navigateur web.
Sélectionnez Nouvel élément.
Entrez un nom pour le travail.
Sélectionnez Pipeline.
Cliquez sur OK.
Sélectionnez Pipeline.
Pour Définition, sélectionnez Script de pipeline à partir de SCM.
Pour SCM, sélectionnez Git.
Entrez l’URL GitHub de votre dépôt dupliqué (forked) : https:\<forked_repo\>.git
Cliquez sur Enregistrer

Tester votre pipeline

Accédez au pipeline que vous avez créé.
Sélectionnez Build Now (Générer maintenant).
Une fois la génération terminée, sélectionnez Console Output (Sortie de console) pour afficher les détails relatifs à la génération.

Vérifier votre application web

Pour vérifier le déploiement du fichier WAR dans votre application web, effectuez les étapes suivantes :

Accédez à l’URL suivante : http://<app_name>.azurewebsites.net/api/calculator/ping

Vous devez voir du texte similaire à celui-ci :

Welcome to Java Web App!!! This is updated!
Today's date

Accédez à l’URL suivante (remplacez x et y par deux valeurs à additionné) : http://< app_name.azurewebsites.net/api/calculator/add?x>=<x>&y=<y>.><><

Déployer sur Azure App Service sur Linux

App Service sur Linux peut aussi héberger des applications web en mode natif sur Linux pour les piles d’applications prises en charge. En outre, il peut exécuter des conteneurs Linux personnalisés (Web App pour conteneurs).

Vous pouvez modifier le script pour le déployer sur Azure App Service sur Linux. App Service sur Linux prend en charge Docker. Pour cela, vous devez fournir un fichier Docker qui intègre votre application web et le runtime du service dans une image Docker. Le plug-in crée l’image, l’envoie (push) vers un registre Docker et déploie l’image sur votre application web.

Reportez-vous à Migrer des logiciels personnalisés vers Azure App Service à l’aide d’un conteneur personnalisé pour créer une version Azure App Service sur Linux et un service Azure Container Registry.

    az group create --name myResourceGroup2 --location westus2
    az acr create --name myACRName --resource-group myResourceGroup2 --sku Basic --admin-enabled true
    az appservice plan create --name myAppServicePlan --resource-group  myResourceGroup2 --is-linux
    az webapp create --resource-group myResourceGroup2 --plan myAppServicePlan --name myApp --deployment-container-image-name myACRName.azurecr.io/calculator:latest

Installez Docker dans Jenkins.
Vérifiez que le plug-in Docker Pipeline est installé.
Dans le même dépôt dupliqué Application web Java simple pour Azure, modifiez le fichier Jenkinsfile2 de la façon suivante :
1. Mettez à jour l’ID d’abonnement et l’ID de locataire.
```
 withEnv(['AZURE_SUBSCRIPTION_ID=<mySubscriptionId>',
        'AZURE_TENANT_ID=<myTenantId>']) {
```
2. Mettez à jour le nom du groupe de ressources, de l’application web et du registre de conteneurs (en remplaçant les espaces réservés par vos valeurs).
```
def webAppResourceGroup = '<resource_group>'
def webAppName = '<app_name>'
def acrName = '<registry>'
```
3. Remplacez <azsrvprincipal\> par votre ID d’identification.
```
withCredentials([usernamePassword(credentialsId: '<service_principal>', passwordVariable: 'AZURE_CLIENT_SECRET', usernameVariable: 'AZURE_CLIENT_ID')]) {
```
Créez un pipeline Jenkins comme vous l’avez fait lorsque vous avez effectué le déploiement sur une application web Azure dans Windows avec Jenkinsfile2.
Exécutez votre nouveau travail.
Pour connaître les résultats, dans Azure CLI, exécutez la commande suivante :
```
az acr repository list -n <myRegistry> -o json
```
Vous devez normalement voir des résultats similaires à ceci :
```
[
"calculator"
]
```
Accédez à http://<app_name>.azurewebsites.net/api/calculator/ping (en remplaçant la valeur de l’espace réservé). Vous devez obtenir des résultats similaires à ceux-ci :
```
Welcome to Java Web App!!! This is updated!
Today's date
```
Accédez à http://<app_name>.azurewebsites.net/api/calculator/add?x=<x>&y=<y> (en remplaçant la valeur des espaces réservés). Les valeurs que vous spécifiez pour x et y sont additionnées puis affichées.

Étapes suivantes

Jenkins sur Azure