Automatiser les déploiements d’applications dans Azure Spring Apps

  • Article

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.

Cet article s’applique au : Niveau ✔️ De base/Standard ✔️ Entreprise

Cet article vous explique comment utiliser la tâche Azure Spring Apps pour Azure pipelines afin de déployer des applications.

Les outils d’intégration continue et de livraison continue vous permettent de déployer rapidement des mises à jour d’applications existantes avec un minimum d’effort et de risque. Azure DevOps vous aide à organiser et à contrôler ces travaux clés.

La vidéo suivante décrit l’automatisation de bout en bout à l’aide des outils de votre choix, y compris Azure Pipelines.


Créer une connexion de service Azure Resource Manager

Tout d’abord, créez une connexion de service du Gestionnaire de ressource Azure à votre projet Azure DevOps. Pour obtenir des instructions, consultez Se connecter à Microsoft Azure. Veillez à sélectionner le même abonnement que celui utilisé pour votre instance de service Azure Spring Apps.

Créer et déployer des applications

Vous pouvez désormais générer et déployer vos projets à l’aide d’une série de tâches. Le modèle de Pipelines Azure suivant définit des variables, une tâche .NET Core pour générer l’application et une tâche Azure Spring Apps pour déployer l’application.

variables:
  workingDirectory: './steeltoe-sample'
  planetMainEntry: 'Microsoft.Azure.SpringCloud.Sample.PlanetWeatherProvider.dll'
  solarMainEntry: 'Microsoft.Azure.SpringCloud.Sample.SolarSystemWeather.dll'
  planetAppName: 'planet-weather-provider'
  solarAppName: 'solar-system-weather'
  serviceName: '<your service name>'

steps:
# Restore, build, publish and package the zipped planet app
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: false
    arguments: '--configuration Release'
    zipAfterPublish: false
    modifyOutputPath: false
    workingDirectory: $(workingDirectory)

# Deploy the planet app
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<Service Connection Name>'
    Action: 'Deploy'
    AzureSpringCloud: $(serviceName)
    AppName: 'testapp'
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(workingDirectory)/src/$(planetAppName)/publish-deploy-planet.zip
    RuntimeVersion: 'NetCore_31'
    DotNetCoreMainEntryPath: $(planetMainEntry)

# Deploy the solar app
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<Service Connection Name>'
    Action: 'Deploy'
    AzureSpringCloud: $(serviceName)
    AppName: 'testapp'
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(workingDirectory)/src/$(solarAppName)/publish-deploy-solar.zip
    RuntimeVersion: 'NetCore_31'
    DotNetCoreMainEntryPath: $(solarMainEntry)

Configurer une instance Azure Spring Apps et un projet Azure DevOps

Tout d’abord, procédez comme suit pour configurer une instance Azure Spring Apps existante à utiliser avec Azure DevOps.

  1. Accédez à votre instance Azure Spring Apps, puis créez une nouvelle application.
  2. Accédez au portail Azure DevOps, puis créez un nouveau projet sous l’organisation que vous avez choisie. Si vous ne possédez pas d’organisation Azure DevOps, vous pouvez en créer une gratuitement.
  3. Sélectionnez Repos, puis importez le code de démonstration Spring Boot dans le référentiel.

Créer une connexion de service Azure Resource Manager

Ensuite, créez une connexion de service du Gestionnaire de ressource Azure à votre projet Azure DevOps. Pour obtenir des instructions, consultez Se connecter à Microsoft Azure. Veillez à sélectionner le même abonnement que celui utilisé pour votre instance de service Azure Spring Apps.

Créer et déployer des applications

Vous pouvez désormais générer et déployer vos projets à l’aide d’une série de tâches. Les sections suivantes présentent différentes options de déploiement de votre application à l’aide d’Azure DevOps.

Déployer à l’aide d’un pipeline

Pour déployer un pipeline, procédez comme suit :

  1. Sélectionnez Pipelines, puis créez un nouveau pipeline avec un modèle Maven.

  2. Modifiez le fichier azure-pipelines.yml pour définir le mavenPomFile champ sur « complete/pom.xml ».

  3. Sélectionnez Afficher l’Assistant sur le côté droit, puis sélectionnez le modèle Azure Spring Apps.

  4. Sélectionnez la connexion de service que vous avez créée pour votre abonnement Azure, puis sélectionnez votre instance Azure Spring Apps et votre instance d’application.

  5. Désactiver Utiliser le déploiement intermédiaire.

  6. Définissez Package ou dossier sur complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.

  7. Sélectionnez Ajouter pour ajouter cette tâche à votre pipeline.

    Les paramètres de votre pipeline doivent correspondre à l’image suivante.

    Capture d'écran d'Azure DevOps qui affiche les paramètres du nouveau pipeline.

    Vous pouvez également générer et déployer vos projets à l’aide du modèle de pipeline suivant. Cet exemple définit tout d’abord une tâche Maven pour générer l’application, suivie d’une deuxième tâche qui déploie le fichier JAR à l’aide de la tâche Azure Spring Apps pour Azure Pipelines.

    steps:
- task: Maven@3
  inputs:
    mavenPomFile: 'complete/pom.xml'
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: ./target/your-result-jar.jar

  8. Sélectionnez Enregistrer et exécuter, puis attendez que la tâche se termine.

Déploiement Blue-Green

Le déploiement présenté dans la section précédente reçoit immédiatement le trafic de l’application lors du déploiement. Cela vous permet de tester l’application dans l’environnement de production avant de recevoir le trafic des clients.

Modifier le fichier du pipeline

Pour générer l’application de la même façon que celle présentée précédemment et la déployer dans un déploiement intermédiaire, utilisez le modèle suivant. Dans cet exemple, le déploiement intermédiaire doit déjà exister. Pour une autre approche, consultez Stratégies de déploiement bleu-vert.

steps:
- task: Maven@3
  inputs:
    mavenPomFile: 'pom.xml'
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    DeploymentType: 'Artifacts'
    UseStagingDeployment: true
    Package: ./target/your-result-jar.jar
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Set Production'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    UseStagingDeployment: true

Utiliser la section Publications

Les étapes suivantes vous montrent comment activer un déploiement Blue-Green à partir de la section Publications .

  1. Sélectionnez Pipelines, créez un nouveau pipeline pour votre build Maven et publiez l’artefact.

    1. sélectionnez Azure Repos Git pour votre emplacement de code.
    2. Sélectionnez un référentiel dans lequel se trouve votre code.
    3. Sélectionnez le modèle Maven et modifiez le fichier pour définir le mavenPomFile champ sur complete/pom.xml .
    4. Sélectionnez Afficher l’Assistant sur le côté droit et sélectionnez le modèle Publier les artefacts de build.
    5. Définissez le Chemin d’accès à publier sur complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.
    6. Sélectionnez Enregistrer et exécuter.

  2. Sélectionnez Publications, puis Créer une publication.

  3. Ajoutez un nouveau pipeline, puis sélectionnez Travail vide pour créer un travail.

  4. Sous Etapes, sélectionnez la ligne 1 travail, 0 tâche

    Capture d'écran d'Azure DevOps qui affiche l'onglet Pipelines avec le lien 1 tâche, 0 tâche en surbrillance.

    1. Sélectionnez le + pour ajouter une tâche au travail.
    2. Recherchez le modèle Azure Spring Apps, puis sélectionnez Ajouter pour ajouter la tâche au travail.
    3. Sélectionnez Déploiement Azure Spring Apps : pour modifier la tâche.
    4. Complétez cette tâche avec les informations de votre application, puis désactivez l'Utilisation du déploiement intermédiaire.
    5. Activez Créer un déploiement intermédiaire s’il n’en existe pas, puis entrez un nom dans Déploiement.
    6. Sélectionnez Enregistrer pour enregistrer cette tâche.
    7. Cliquez sur OK.

  5. Sous l'onglet Pipeline, sélectionnez ensuite Ajouter un artefact.

    1. Sous source (pipeline de Build), sélectionnez le pipeline créé précédemment.
    2. Sélectionnez Ajouter, puis Enregistrer.

  6. Sélectionnez 1 travail, 1 tâche sous Etapes.

  7. Accédez à la tâche de Déploiement Azure Spring Apps de l’Étape 1, puis sélectionnez les points de suspension en regard de Package ou dossier.

  8. Sélectionnez spring-boot-complete-0.0.1-SNAPSHOT.jar dans la boîte de dialogue, puis sélectionnez OK.

    Capture d’écran d’Azure DevOps montrant la boîte de dialogue Sélectionner un fichier ou un dossier.

  9. Sélectionnez le + pour ajouter une autre tâche Azure Spring Apps au travail.

  10. Modifiez l’action pour Définir le déploiement de production.

  11. Sélectionnez Enregistrer, puis Créer une publication pour démarrer automatiquement le déploiement.

Pour vérifier l’état de publication actuel de votre application, sélectionnez Afficher la publication. Une fois cette tâche terminée, accédez au Portail Azure pour vérifier l’état de votre application.

Déployer à partir de la source

Pour déployer directement sur Azure sans étape de génération distincte, utilisez le modèle de pipeline suivant.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(Build.SourcesDirectory)

Déployer à partir d’une image personnalisée

Pour déployer directement à partir d’une image conteneur existante, utilisez le modèle de pipeline suivant.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: '<your Azure Spring Apps service>'
    AppName: '<app-name>'
    DeploymentType: 'CustomContainer'
    UseStagingDeployment: false
    DeploymentName: 'default'
    ContainerRegistry: 'docker.io'  # or your Azure Container Registry, e.g: 'contoso.azurecr.io'
    RegistryUsername: '$(username)'
    RegistryPassword: '$(password)'
    ContainerImage: '<your image tag>'

Déployer et spécifier un générateur (plan Entreprise uniquement)

Si vous utilisez le plan Azure Spring Apps Enterprise, vous pouvez également spécifier le générateur à utiliser pour déployer des actions à l’aide de l’option builder , comme illustré dans l’exemple suivant. Pour plus d’informations, consultez Utiliser le service de build Tanzu.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your-service-connection-name>'
    Action: 'Deploy'
    AzureSpringCloud: '<your-Azure-Spring-Apps-service-instance-name>'
    AppName: '<app-name>'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: './target/your-result-jar.jar'
    Builder: '<your-Tanzu-Build-Service-Builder-resource>'

Étapes suivantes