Tutoriel : Déployer des applications sur Azure Spring Apps à l’aide de Jenkins et de l’interface Azure CLI

Article
10/23/2023

Remarque

Azure Spring Apps est le nouveau nom du service Azure Spring Cloud. Bien que le service ait un nouveau nom, vous verrez l’ancien nom à divers endroits pendant un certain temps, car nous travaillons à mettre à jour les ressources telles que les captures d’écran, les vidéos et les diagrammes.

Azure Spring Apps est un développement de microservice entièrement géré avec la découverte de services et la gestion de la configuration intégrées. Le service permet de déployer facilement des applications de microservices basées sur Spring boot sur Azure. Ce tutoriel montre comment utiliser Azure CLI dans Jenkins pour automatiser l’intégration et la livraison continues (CI/CD) pour Azure Spring Apps.

Dans ce tutoriel, vous allez effectuer les tâches suivantes :

Provisionner une instance de service et lancer une application Java Spring
Préparer votre serveur Jenkins
Utiliser Azure CLI dans un pipeline Jenkins pour générer et déployer les applications de microservices

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
Compte GitHub : si vous n’avez pas de compte GitHub, créez un compte gratuit avant de commencer.

Provisionner une instance de service et lancer une application Java Spring

Nous utilisons Piggy Metrics comme exemple d’application de service Microsoft et suivons les mêmes étapes dans le guide de démarrage rapide : Lancez une application Java Spring à l’aide d’Azure CLI pour approvisionner l’instance de service et configurer les applications. Si vous avez déjà effectué le même processus, vous pouvez passer à la section suivante. Sinon, les commandes Azure CLI sont listées plus loin. Reportez-vous au guide de démarrage rapide : Lancer une application Java Spring à l’aide d’Azure CLI pour obtenir plus d’informations.

Votre ordinateur local doit satisfaire les même prérequis que le serveur de build Jenkins. Vérifiez que les éléments suivants sont installés pour pouvoir générer et déployer les applications de microservices :

Git
JDK 8
Maven 3.0 ou ultérieur
Azure CLI version 2.0.67 ou ultérieure installée.

Installez l’extension Azure Spring Apps :
```
az extension add --name spring
```
Créez un groupe de ressources pour contenir votre service Azure Spring Apps :
```
az group create --location eastus --name <resource group name>
```

Provisionnez une instance d’Azure Spring Apps :

az spring create -n <service name> -g <resource group name>

Dupliquez (fork) le dépôt Piggy Metrics sur votre propre compte GitHub. Sur votre ordinateur local, clonez votre dépôt dans un répertoire appelé source-code :
```
mkdir source-code
git clone https://github.com/<your GitHub id>/piggymetrics
```

Configurez votre serveur de configuration. Veillez à remplacer <your GitHub id> par la valeur correcte.

az spring config-server git set -n <your-service-name> --uri https://github.com/<your GitHub id>/piggymetrics --label config

Générez le projet :

cd piggymetrics
mvn clean package -D skipTests

Créez les trois microservices : gateway, auth-service et account-service :

az spring app create --n gateway -s <service name> -g <resource group name>
az spring app create --n auth-service -s <service name> -g <resource group name>
az spring app create --n account-service -s <service name> -g <resource group name>

Déployez les applications :

az spring app deploy -n gateway -s <service name> -g <resource group name> --jar-path ./gateway/target/gateway.jar
az spring app deploy -n account-service -s <service name> -g <resource group name> --jar-path ./account-service/target/account-service.jar
az spring app deploy -n auth-service -s <service name> -g <resource group name> --jar-path ./auth-service/target/auth-service.jar

Affectez un point de terminaison public à la passerelle :

az spring app update -n gateway -s <service name> -g <resource group name> --is-public true

Interrogez l’application de passerelle pour obtenir l’URL afin de pouvoir vérifier que l’application est en cours d’exécution.
```
az spring app show --name gateway | grep url
```
Accédez à l’URL fournie par la commande précédente pour exécuter l’application PiggyMetrics.

Préparer le serveur Jenkins

Dans cette section, vous allez préparer le serveur Jenkins pour exécuter une build, ce qui est parfait pour effectuer des tests. Toutefois, en raison de l’implication en terme de sécurité, vous devez utiliser un agent de machine virtuelle Azure ou un agent de conteneur Azure pour mettre en place un agent dans Azure afin d’exécuter vos builds.

Installer les plug-ins

Connectez-vous à votre serveur Jenkins.
Sélectionnez Manage Jenkins (Gérer Jenkins).
Select Manage Plugins (Gérer les plug-ins).
Sous l’onglet Disponibles, sélectionnez les plug-ins suivants :
- GitHub Integration
- Informations d’identification Azure
Si ces plug-ins ne sont pas listés, examinez l’onglet Installés pour voir s’ils sont déjà installés.
Pour installer les plug-ins, sélectionnez Télécharger maintenant et installer après le redémarrage.
Redémarrez votre serveur Jenkins pour terminer l’installation.

Ajouter vos informations d’identification de principal de service Azure dans le magasin d’informations d’identification Jenkins

Un principal de service Azure est nécessaire pour les déploiements sur Azure. Pour plus d’informations, consultez la section Créer le principal de service du tutoriel Déployer dans Azure App Service. La sortie de az ad sp create-for-rbac ressemble à ceci :
```
{
    "appId": "xxxxxx-xxx-xxxx-xxx-xxxxxxxxxxxx",
    "displayName": "xxxxxxxjenkinssp",
    "name": "http://xxxxxxxjenkinssp",
    "password": "xxxxxx-xxx-xxxx-xxx-xxxxxxxxxxxx",
    "tenant": "xxxxxx--xxx-xxxx-xxx-xxxxxxxxxxxx"
}
```
Dans le tableau de bord Jenkins, sélectionnez Informations d’identification>Système. Puis, sélectionnez Informations d’identification globales (sans restriction).
Sélectionnez Ajouter des informations d’identification.
Sélectionnez Principal de service Microsoft Azure comme type.
Fournissez les valeurs dans les champs suivants :
- ID de l'abonnement : ID d’abonnement Azure
- ID client : appid du principal de service
- Clé secrète client : mot de passe du principal de service
- ID de locataire : ID de locataire du compte Microsoft
- Environnement Azure : sélectionnez la valeur appropriée pour votre environnement. Par exemple, utilisez Azure pour Azure Global.
- ID : défini sur azure_service_principal. Nous utilisons cet ID dans une étape ultérieure du présent article.
- Description : Cette valeur est facultative, mais recommandée du point de vue de la documentation/maintenance.

Installer l’extension Spring Maven et Azure CLI

L’exemple de pipeline utilise Maven pour générer et Azure CLI pour effectuer le déploiement sur l’instance de service. Quand Jenkins est installé, il crée un compte administrateur nommé jenkins. Vérifiez que l’utilisateur jenkins dispose de l’autorisation d’exécuter l’extension spring.

Connectez-vous au contrôleur Jenkins par le biais du protocole SSH.
Installez Maven.
```
sudo apt-get install maven
```
Vérifiez que l’interface de ligne de commande Azure est installée en entrant az version. Si l’interface de ligne de commande Azure n’est pas installée, consultez Installation d’Azure CLI.
Passez à l’utilisateur jenkins :
```
sudo su jenkins
```
Installez l’extension spring :
```
az extension add --name spring
```

Créer un Jenkinsfile

Dans votre propre dépôt : https://github.com/your_github_id/piggymetrics créez un fichier Jenkins dans la racine.

Mettez le fichier à jour comme suit. Veillez à remplacer les valeurs du nom> du groupe de ressources et <du nom> du <service. Remplacez azure_service_principal par l’ID approprié si vous avez utilisé une valeur différente quand vous avez ajouté les informations d’identification dans Jenkins.

    node {
      stage('init') {
        checkout scm
      }
      stage('build') {
        sh 'mvn clean package'
      }
      stage('deploy') {
        withCredentials([azureServicePrincipal('azure_service_principal')]) {
          // Log in to Azure
          sh '''
            az login --service-principal -u $AZURE_CLIENT_ID -p $AZURE_CLIENT_SECRET -t $AZURE_TENANT_ID
            az account set -s $AZURE_SUBSCRIPTION_ID
          '''  
          // Set default resource group name and service name. Replace <resource group name> and <service name> with the right values
          sh 'az config set defaults.group=<resource group name>'
          sh 'az config set defaults.spring=<service name>'

          // Deploy applications
          sh 'az spring app deploy -n gateway --jar-path ./gateway/target/gateway.jar'
          sh 'az spring app deploy -n account-service --jar-path ./account-service/target/account-service.jar'
          sh 'az spring app deploy -n auth-service --jar-path ./auth-service/target/auth-service.jar'
          sh 'az logout'
        }
      }
    }

Enregistrez et validez la modification.

Créer le travail

Dans le tableau de bord Jenkins, sélectionnez Nouvel élément.
Spécifiez un nom, Deploy-PiggyMetrics, pour le travail et sélectionnez Pipeline. Cliquez sur OK.
Sélectionnez l’onglet 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é : https://github.com/<your GitHub id>/piggymetrics.git.
Pour le spécificateur de branche (noir pour « any ») , sélectionnez /Azure.
Pour le chemin de script, sélectionnez Jenkinsfile.
Sélectionnez Enregistrer.

Valider et exécuter le travail

Avant d’exécuter le travail, modifiez le texte dans la zone d’entrée de connexion pour entrer l’ID de connexion.

Dans votre dépôt, ouvrez index.html dans /gateway/src/main/resources/static/.

enter your login Recherchez et mettez à jour ce texte sur enter login ID.

<input class="frontforms" id="frontloginform" name="username" placeholder="enter login ID" type="text" autocomplete="off"/>

Enregistrez et validez la modification.
Exécutez le travail manuellement dans Jenkins. Dans le tableau de bord Jenkins, sélectionnez le travail Deploy-PiggyMetrics , puis sélectionnez Générer maintenant.

Une fois le travail terminé, accédez à l’adresse IP publique de l’application gateway et vérifiez que votre application a été mise à jour.

Updated Piggy Metrics

Nettoyer les ressources

Quand vous n’en avez plus besoin, supprimez les ressources créées dans cet article :

az group delete -y --no-wait -n <resource group name>

Étapes suivantes

Jenkins sur Azure