Déployer sur App Service avec Azure Pipelines

1. Connectez-vous à votre organisation Azure DevOps et accédez à votre projet.

2. Accédez à Pipelines, puis sélectionnez Nouveau pipeline.

3. Lorsque vous y êtes invité, sélectionnez l’emplacement de votre code source : Azure Repos Git ou GitHub.

   Vous serez peut-être redirigé vers GitHub pour vous connecter. Si c’est le cas, entrez vos informations d’identification GitHub.

4. Quand la liste des dépôts s’affiche, sélectionnez votre dépôt.

5. Vous serez peut-être redirigé vers GitHub pour pouvoir installer l’application Azure Pipelines. Si c’est le cas, sélectionnez Approuver et installer.

6. Quand l’onglet Configurer s’affiche, sélectionnez ASP.NET Core.

7. Quand votre nouveau pipeline s’affiche, examinez le code YAML pour voir ce qu’il fait. Lorsque vous êtes prêt, sélectionnez Enregistrer et exécuter.

Pour commencer :

1. Créez un pipeline, puis sélectionnez le modèle ASP.NET Core. Cette sélection ajoute automatiquement les tâches requises pour générer le code dans l’exemple de référentiel.

2. Enregistrez le pipeline et mettez en file d’attente une build pour la voir en action.

   Le modèle de pipeline ASP.NET Core publie le fichier ZIP de déploiement en tant qu’artefact Azure pour la tâche de déploiement ultérieurement.

1. Cliquez sur la fin du fichier YAML, puis sélectionnez Afficher l’Assistant.

2. Utilisez l’Assistant Tâche pour ajouter la tâche Azure Web App.

   

   Vous pouvez également ajouter la tâche de déploiement Azure App Service (AzureRmWebAppDeployment).

3. Choisissez votre abonnement Azure. Veillez à autoriser votre connexion. L’autorisation crée la connexion de service requise.

4. Sélectionnez le type d’application, le nom de l’application et la pile d’exécution en fonction de votre application App Service. Votre YAML complet doit ressembler au code suivant.

   variables:
     buildConfiguration: 'Release'
   
   steps:
   - task: DotNetCoreCLI@2
     inputs:
       command: 'publish'
       publishWebProjects: true
   - task: AzureWebApp@1
     inputs:
       azureSubscription: '<service-connection-name>'
       appType: 'webAppLinux'
       appName: '<app-name>'
       package: '$(System.DefaultWorkingDirectory)/**/*.zip'
   

   • azureSubscription : nom de la connexion de service autorisée à votre abonnement Azure.
   • appName : nom de votre application existante.
   • package : chemin de fichier vers le package ou un dossier qui héberge le contenu de votre service d’application. Les caractères génériques sont pris en charge.

Pour commencer :

1. Créez un pipeline de mise en production en sélectionnant Versions dans le menu de gauche, puis sélectionnez Nouveau pipeline.

2. Sélectionnez le modèle Déploiement d’Azure App Service pour votre index. Cela a pour effet d’ajouter automatiquement les tâches nécessaires.

   Remarque

   Si vous déployez une application Node.js sur App Service sur Windows, sélectionnez le modèle Déployer une application Node.js sur Azure App Service. La seule différence entre ces modèles est que le modèle Node.js configure la tâche pour générer un fichier web.config contenant un paramètre qui démarre le service iisnode.

3. Pour lier ce pipeline de mise en production à l’artefact Azure à l’étape précédente, sélectionnez Ajouter un artefact>Build.

4. Dans Source (pipeline de build), sélectionnez le pipeline de build que vous avez créé dans la section précédente, puis sélectionnez Ajouter.

5. Enregistrez le pipeline de mise en production et créez une mise en production pour la voir en action.

Pour déployer un package web .zip (par exemple, à partir d’une application web ASP.NET) vers une application web Azure, utilisez l’extrait de code suivant pour déployer la build sur une application.

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: 'webAppLinux'
    appName: '<app-name>'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

• azureSubscription : votre abonnement Azure.
• appType : type de votre application web.
• appName : nom de votre service d’application existant.
• package : chemin du fichier de package ou d’un dossier stockant le contenu de votre service d’application. Les caractères génériques sont pris en charge.

Pour les pipelines classiques, il est plus facile de définir les phases de build et de mise en production dans des pages distinctes (Pipelines et Versions, respectivement). En général, vous :

• Dans la page Pipelines, générez et testez votre application à l’aide du modèle de votre choix, tel que ASP.NET Core, Node.js avec Grunt, Maven ou d’autres, et publiez un artefact.
• Dans la page Version, utilisez le modèle de déploiement Azure App Service générique pour déployer l’artefact.

Il peut y avoir des modèles pour des langages de programmation spécifiques à choisir.

Par défaut, votre déploiement se produit sur l’application racine dans l’application web Azure. Vous pouvez déployer sur une application virtuelle spécifique à l’aide de la propriété VirtualApplication de la tâche de déploiement Azure App Service (AzureRmWebAppDeployment) :

- task: AzureRmWebAppDeployment@4
  inputs:
    VirtualApplication: '<name of virtual application>'

• VirtualApplication : nom de l’application virtuelle configurée dans le portail Microsoft Azure. Pour plus d’informations, consultez Configurer une application App Service dans le portail Azure.

Par défaut, votre déploiement se produit sur l’application racine dans l’application web Azure. Si vous souhaitez déployer sur une application virtuelle spécifique, entrez le nom de celle-ci dans la propriété Application virtuelle de la tâche de déploiement d’Azure App Service.

L’exemple suivant montre comment effectuer un déploiement vers un emplacement de préproduction, puis dans un emplacement de production :

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    appName: '<app-name>'
    deployToSlotOrASE: true
    resourceGroupName: '<name of resource group>'
    slotName: staging
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    WebAppName: '<app-name>'
    ResourceGroupName: '<name of resource group>'
    SourceSlot: staging
    SwapWithProduction: true

• azureSubscription : votre abonnement Azure.
• appType (facultatif) : utilisez webAppLinux pour effectuer un déploiement vers une application web sur Linux.
• appName : nom de votre service d’application existant.
• deployToSlotOrASE : booléen. Déployez dans un emplacement de déploiement existant ou dans Azure App Service Environment.
• resourceGroupName : nom du groupe de ressources. Obligatoire si la valeur de deployToSlotOrASE est true.
• slotName : nom de l’emplacement, par défaut à production. Obligatoire si la valeur de deployToSlotOrASE est true.
• package : chemin du fichier de package ou d’un dossier stockant le contenu de votre service d’application. Les caractères génériques sont pris en charge.
• SourceSlot : emplacement envoyé à la production quand la valeur de SwapWithProduction est true.
• SwapWithProduction : booléen. Échangez le trafic de l’emplacement source avec la production.

Utilisez l’option Déployer sur l’emplacement ou l’environnement App Service dans la tâche Azure Web App pour spécifier l’emplacement vers lequel effectuer le déploiement. Pour échanger les emplacements, utilisez la tâche de gestion Azure App Service.

Vous pouvez utiliser des travaux dans votre fichier YAML pour configurer un pipeline de déploiements. En utilisant des travaux, vous pouvez contrôler l’ordre de déploiement sur plusieurs applications web.

jobs:
- job: buildandtest
  pool:
    vmImage: ubuntu-latest
 
  steps:
  # publish an artifact called drop
  - task: PublishPipelineArtifact@1
    inputs:
      targetPath: '$(Build.ArtifactStagingDirectory)' 
      artifactName: drop
  
  # deploy to Azure Web App staging
  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<staging-app-name>'
      deployToSlotOrASE: true
      resourceGroupName: <group-name>
      slotName: 'staging'
      package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- job: deploy
  dependsOn: buildandtest
  condition: succeeded()

  pool: 
    vmImage: ubuntu-latest  
  
  steps:
    # download the artifact drop from the previous job
  - task: DownloadPipelineArtifact@2
    inputs:
      source: 'current'
      artifact: 'drop'
      path: '$(Pipeline.Workspace)'

  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<production-app-name>'
      resourceGroupName: <group-name>
      package: '$(Pipeline.Workspace)/**/*.zip'

Si vous souhaitez déployer sur plusieurs applications web, ajoutez des phases à votre pipeline de mise en production. Vous pouvez contrôler l’ordre du déploiement. Pour en savoir plus, consultez Phases.

L’extrait de code suivant montre un exemple de substitution de variable à l’aide de la tâche de déploiement Azure App Service (AzureRmWebAppDeployment) :

jobs:
- job: test
  variables:
    connectionString: <test-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Test stage Azure service connection>'
      WebAppName: '<name of test stage web app>'
      enableXmlVariableSubstitution: true

- job: prod
  dependsOn: test
  variables:
    connectionString: <prod-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Prod stage Azure service connection>'
      WebAppName: '<name of prod stage web app>'
      enableXmlVariableSubstitution: true

Pour modifier connectionString à l’aide d’une substitution de variable :

1. Créez un pipeline de mise en production en deux phases.
2. Liez l’artefact de la mise en production à la build qui produit le package web.
3. Définissez connectionString comme variable dans chacune des phases. Définissez le valeur appropriée.
4. Sélectionnez Substitution de variable XML sous Options de transformations de fichiers et de substitutions de variables pour la tâche Déploiement d’Azure App Service.

Pour faire cela dans YAML, vous pouvez utiliser l’une des techniques suivantes :

• Isoler les étapes de déploiement dans un travail distinct et ajouter une condition à celui-ci.
• Ajouter une condition à l’étape.

L’exemple suivant montre comment utiliser des conditions d’étape pour déployer uniquement des builds provenant de la branche principale :

- task: AzureWebApp@1
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  inputs:
    azureSubscription: '<service-connection-name>'
    appName: '<app-name>'

Pour en savoir plus sur les conditions, consultez Spécifier des conditions.

Dans votre pipeline de mise en production, vous pouvez implémenter diverses vérifications et conditions pour contrôler le déploiement :

• Définissez des filtres de branche pour configurer le déclencheur de déploiement continu sur l’artefact du pipeline de mise en production.
• Définissez des approbations de pré-déploiement en guise de condition préalable pour le déploiement en index.
• Configurez des portes comme condition préalable au déploiement en index.
• Spécifiez des conditions d’exécution d’une tâche.

Pour plus d’informations, consultez Déclencheurs de mise en production, de branche et de phase, Contrôler le déploiement de mise en production avec des approbations, Contrôler le déploiement de mise en production avec des portes et Spécifier des conditions d’exécution d’une tâche.

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration)'
    zipAfterPublish: true
- task: AzureRmWebAppDeployment@4
  inputs:
    ConnectionType: 'AzureRM'
    azureSubscription: '<service-connection-name>'
    appType: 'webApp'
    WebAppName: '<app-name>'
    packageForLinux: '$(System.DefaultWorkingDirectory)/**/*.zip'
    enableCustomDeployment: true
    DeploymentType: 'webDeploy'

Dans le pipeline de mise en production, en supposant que vous utilisez le modèle de déploiement Azure App Service :

1. Sélectionnez l’onglet Tâches, puis sélectionnez le déploiement Azure App Service. Il s’agit de la tâche AzureRmWebAppDeployment.

2. Dans la boîte de dialogue, vérifiez que le type de connexion est défini sur Azure Resource Manager.

3. Dans la boîte de dialogue, développez Options de déploiement supplémentaires, puis sélectionnez Sélectionner la méthode de déploiement. Assurez-vous que Web Deploy est sélectionné comme méthode de déploiement.

4. Enregistrez le pipeline de mise en production.