Déployer sur App Service avec Azure Pipelines

Azure DevOps Services | Azure DevOps Server 2020 | Azure DevOps Server 2019

Utilisez Azure Pipelines pour déployer automatiquement votre application web sur Azure App Service à chaque build réussie. Azure Pipelines vous permet de créer, tester et déployer avec l’intégration continue (CI) et la livraison continue (CD) à l’aide d’Azure DevOps.

Les pipelines YAML sont définis à l’aide d’un fichier YAML dans votre référentiel. Une étape est le plus petit bloc de construction d’un pipeline, et peut être un script ou une tâche (script prédéfini). En savoir plus sur les principaux concepts et composants qui composent un pipeline.

Vous allez utiliser la tâche Azure Web App (AzureWebApp) pour effectuer un déploiement sur Azure App Service dans votre pipeline. Pour des scénarios plus complexes, tels ceux nécessitant d’utiliser des paramètres XML dans votre déploiement, vous pouvez utiliser la tâche de déploiement d’Azure App Service (AzureRmWebAppDeployment).

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Une organisation Azure DevOps. Créez-en un gratuitement.
• Possibilité d’exécuter des pipelines sur des agents hébergés par Microsoft. Vous pouvez acheter un travail parallèle ou demander un niveau gratuit.
• Une application Azure App Service opérationnelle avec du code hébergé sur GitHub ou Azure Repos.
  • .NET : Créer une application web ASP.NET Core dans Azure
  • ASP.NET : Créer une application web ASP.NET Framework dans Azure
  • JavaScript : Créer une application web Node.js dans Azure App Service
  • Java : Créer une application Java dans Azure App Service
  • Python : Créer une application Python dans Azure App Service

1. Créer un pipeline pour votre pile

Les exemples de code fournis dans cette section partent du principe que vous déployez une application web ASP.NET. Vous pouvez adapter les instructions pour d’autres infrastructures.

Apprenez-en davantage plus sur la prise en charge de l’écosystème Azure Pipelines.

YAML

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.

Classique

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.

2. Ajouter la tâche de déploiement

YAML

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:
   - script: dotnet build --configuration $(buildConfiguration)
     displayName: 'dotnet build $(buildConfiguration)'
   - 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.

Classique

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.

Exemple : déployer une application .NET

YAML

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:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'
- 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.

Classique

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.

Exemple : déployer sur une application virtuelle

YAML

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.

Classique

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.

Exemple : déployer sur un emplacement

YAML

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.

Classique

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.

Exemple : déployer sur plusieurs applications web

YAML

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'

Classique

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.

Exemple : effectuer des substitutions de variables

Pour la plupart des piles de langage, les paramètres d’application et les chaînes de connexion peuvent être définis en tant que variables d’environnement au moment de l’exécution.

Toutefois, il existe d’autres raisons pour lesquelles vous souhaitez effectuer des substitutions de variables à votre fichier Web.config. Dans cet exemple, votre fichier Web.config contient une chaîne de connexion nommée connectionString. Vous pouvez modifier sa valeur avant le déploiement sur chaque application web. Pour ce faire, vous pouvez appliquer une transformation Web.config ou remplacer des variables dans votre fichier Web.config.

YAML

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

Classique

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.

Exemple : déployer de manière conditionnelle

YAML

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.

Classique

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.

Exemple : déployer à l’aide de Web Deploy

La tâche de déploiement Azure App Service (AzureRmWebAppDeployment) peut être déployée sur App Service à l’aide de Web Deploy.

YAML

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'
- 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'

Classique

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.

Remarque

Avec les tâches AzureRmWebAppDeployment@3 et AzureRmWebAppDeployment@4, vous devez utiliser le type de connexion Azure Resource Manager, ou AzureRM lors du déploiement avec Web Deploy. Il utilise des profils de publication pour le déploiement lorsque l’authentification de base est activée pour votre application, mais il utilise l’authentification Entra ID la plus sécurisée lorsque l’authentification de base est désactivée.

Forum aux questions

Quelle est la différence entre les tâches AzureWebApp et AzureRmWebAppDeployment ?

La tâche d’application web Azure (AzureWebApp) est le moyen le plus simple d’opérer un déploiement sur une application web Azure. Par défaut, votre déploiement se produit sur l’application racine dans l’application web Azure.

La tâche de déploiement Azure App Service (AzureRmWebAppDeployment) peut gérer des scénarios plus personnalisés, tels que :

• Modifiez les paramètres de configuration dans les packages web et les fichiers de paramètres XML.
• Déployez avec Web Deploy, si vous êtes habitué au processus de déploiement IIS.
• Déployez sur des applications virtuelles.
• Déployez sur d’autres types d’applications, tels que les applications conteneur, les applications de fonction, les WebJobs ou les applications API et mobile.

Remarque

Les transformations de fichiers et substitutions de variables sont également prises en charge par la tâche Transformation de fichier à utiliser dans Azure Pipelines. Vous pouvez utiliser la tâche Transformation de fichier pour appliquer des transformations de fichiers et substitutions de variables à tout fichier de configuration et de paramètres.

J’obtiens le message « Package App Service ou chemin d’accès de dossier non valide ».

Dans les pipelines YAML, selon votre pipeline, il peut y avoir une incompatibilité entre l’emplacement d’enregistrement de votre package web généré et l’emplacement où la tâche de déploiement le recherche. Par exemple, la tâche AzureWebApp récupère le package web pour le déploiement. Par exemple, la tâche AzureWebApp recherche dans $(System.DefaultWorkingDirectory)/**/*.zip. Si le package web est déposé ailleurs, modifiez la valeur de package.

J’obtiens le message « La publication à l’aide des options webdeploy est prise en charge uniquement lors de l’utilisation de l’agent Windows ».

Cette erreur se produit dans la tâche AzureRmWebAppDeployment lorsque vous configurez la tâche à déployer à l’aide de Web Deploy, mais que votre agent n’exécute pas Windows. Vérifiez que votre YAML a quelque chose de similaire au code suivant :

pool:
  vmImage: windows-latest

Web Deploy ne fonctionne pas lorsque je désactive l’authentification de base

Pour plus d’informations sur la résolution des problèmes liés à l’utilisation de l’authentification Microsoft Entra ID avec la tâche AzureRmWebAppDeployment, consultez Je ne parviens pas à utiliser Web Deploy sur Azure App Service à l’aide de l’authentification Microsoft Entra ID à partir de mon agent Windows

Étapes suivantes

• Personnalisez votre Pipeline Azure DevOps.