Partager via


Déployer sur App Service avec Azure Pipelines

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

Remarque

Depuis le 1er juin 2024, toutes les applications App Service nouvellement créées ont la possibilité de générer un nom d’hôte par défaut unique en utilisant la convention d’affectation de noms <app-name>-<random-hash>.<region>.azurewebsites.net. Les noms d’application existants restent inchangés.

Exemple : myapp-ds27dh7271aah175.westus-01.azurewebsites.net

Pour plus d’informations, reportez-vous à Nom d’hôte par défaut unique pour les ressources App Service.

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

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.

  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.

2. Ajouter la tâche de déploiement

  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.

    Capture d’écran de 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.

Exemple : déployer une application .NET

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.

Exemple : déployer sur une application virtuelle

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>'

Exemple : déployer sur un emplacement

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.

Exemple : déployer sur plusieurs applications web

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'

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.

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

Exemple : déployer de manière conditionnelle

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.

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.

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'

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 :

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