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

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 déployer une application web Java sur Azure, vous pouvez utiliser Azure CLI dans un pipeline Jenkins. Dans ce tutoriel, vous effectuez 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

Conditions préalables

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 requis et Maven sur le contrôleur Jenkins :

Connectez-vous au contrôleur Jenkins à l’aide de SSH.

Téléchargez et installez la build Azul Zulu d’OpenJDK pour Azure à partir d’un dépôt 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 un principal de service Azure à un identifiant 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 Informations d’identification globales (illimitées).
Sélectionnez Ajouter des informations d’identification pour ajouter un principal de service Microsoft Azure. Vérifiez que le type d’informations d’identification est Nom d’utilisateur avec mot de passe et entrez les éléments suivants :
- Nom d’utilisateur : Principal de service appId
- Mot de passe : Service principal password
- ID : Identificateur de crédentiel (par exemple AzureServicePrincipal)

Créer un service Azure App Service pour le déploiement de 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 appservice définit les ressources physiques utilisées pour héberger vos applications.
Toutes les applications affectées à un plan AppService partagent ces ressources.
Les plans AppService vous permettent d’économiser des coûts lors de l’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 myAppServicePlan plan App Service.

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

Points essentiels :

La définition de l’application web fournit une URL permettant d’accéder à votre application et configure plusieurs options pour déployer votre code sur Azure.
Remplacez l’espace <app_name> réservé par un nom d’application unique.
Le nom de l’application fait partie du nom de domaine par défaut de l’application web. Par conséquent, le nom doit être unique dans toutes les applications dans Azure.
Vous pouvez mapper une entrée de nom de domaine personnalisée à l’application web avant de l’exposer à vos utilisateurs.

Configurer Java

Utilisez az appservice web config update pour configurer 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 référentiel Simple Java Web App pour Azure .
Sélectionnez le bouton Fork pour dupliquer 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 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 sur la ligne 22 et 23 respectivement.
```
def resourceGroup = '<resource_group>'
def webAppName = '<app_name>'
```

Mettre à jour l'ID des identifiants dans votre instance Jenkins

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

Créer un pipeline Jenkins

Procédez comme suit pour créer un pipeline Jenkins :

Ouvrez Jenkins dans un navigateur web.
Sélectionnez Nouvel élément.
Entrez un nom pour la tâche.
Sélectionnez Pipeline.
Cliquez sur OK.
Sélectionnez Pipeline.
Pour la définition, sélectionnez le script de pipeline depuis SCM.
Pour SCM, sélectionnez Git.
Entrez l’URL GitHub de votre dépôt dupliqué : https:\<forked_repo\>.git
Cliquez sur Enregistrer

Testez votre pipeline

Accédez au pipeline que vous avez créé
Sélectionner Générer maintenant
Une fois la build terminée, sélectionnez Sortie de la console pour afficher les détails de la build.

Vérifier votre application web

Procédez comme suit pour vérifier que le fichier WAR est déployé avec succès sur votre application web :

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

Vous devez voir du texte similaire à ce qui suit :

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

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

Déployer sur Azure App Service sous 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. Il peut également exécuter des conteneurs Linux personnalisés (également appelé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. Par conséquent, vous fournissez un fichier Dockerfile qui empaquette votre application web avec le runtime de service dans une image Docker. Le plug-in génère l’image, l’envoie (push) dans 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 un service Azure App Service sur Linux et 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 sur votre Jenkins.
Vérifiez que le plug-in Docker Pipeline est installé.
Dans le même dépôt Simple Java Web App for Azure que vous avez forké, modifiez le fichier Jenkinsfile2 comme suit :
1. Mettez à jour l’ID d’abonnement et l’ID de locataire.
```
 withEnv(['AZURE_SUBSCRIPTION_ID=<mySubscriptionId>',
        'AZURE_TENANT_ID=<myTenantId>']) {
```
2. Mettez à jour les noms de votre groupe de ressources, application web et ACR (en remplaçant les espaces réservés par vos valeurs).
```
def webAppResourceGroup = '<resource_group>'
def webAppName = '<app_name>'
def acrName = '<registry>'
```
3. Mettre à jour <azsrvprincipal\> vers votre identifiant de connexion
```
withCredentials([usernamePassword(credentialsId: '<service_principal>', passwordVariable: 'AZURE_CLIENT_SECRET', usernameVariable: 'AZURE_CLIENT_ID')]) {
```
Créez un nouveau pipeline Jenkins comme lorsque vous avez déployé sur une application web Azure sous Windows à l'aide de Jenkinsfile2.
Exécutez votre nouveau travail.
Pour vérifier, dans Azure CLI, exécutez la commande suivante :
```
az acr repository list -n <myRegistry> -o json
```
Vous devez voir les résultats similaires à ce qui suit :
```
[
"calculator"
]
```
Accédez à http://<app_name>.azurewebsites.net/api/calculator/ping (en remplaçant l’espace réservé). Vous devez obtenir des résultats similaires à ceux-ci :
```
Welcome to Java Web App!!! This is updated!
Today's date
```
Naviguez vers http://<app_name>.azurewebsites.net/api/calculator/add?x=<x>&y=<y> (en remplaçant les espaces réservés). Les valeurs que vous spécifiez pour x et y sont additionnées et affichées.

Étapes suivantes

Jenkins sur Azure

Partager via