Distribuera till Azure App Service med hjälp av Azure Pipelines

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

Använd Azure Pipelines för att automatiskt distribuera din webbapp till Azure App Service vid varje lyckad version. Med Azure Pipelines kan du skapa, testa och distribuera med kontinuerlig integrering och kontinuerlig leverans (CI/CD) med hjälp av Azure DevOps.

YAML-pipelines definieras genom en YAML-fil i din lagringsplats. Ett steg är det minsta byggblocket i en pipeline och kan vara ett skript eller en uppgift (förpaketerat skript). Lär dig mer om viktiga begrepp och komponenter som utgör en pipeline.

Du använder Azure Web App-uppdraget (AzureWebApp) för att implementera i Azure App Service i din pipeline. För mer komplicerade scenarier, till exempel när du behöver använda XML-parametrar i distributionen, kan du använda Azure App Service-distributionsuppgiften AzureRmWebAppDeployment.

Förutsättningar:

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• En organisation på Azure DevOps. Skapa en kostnadsfritt.
• Möjligheten att köra pipelines på agenter som är värdar för Microsoft. Du kan köpa ett parallellt jobb eller begära en kostnadsfri nivå.
• En fungerande Azure App Service-app med koden som finns på GitHub eller Azure Repos.
  • .NET: Skapa en ASP.NET Core-webbapp i Azure.
  • ASP.NET: Skapa en ASP.NET Framework-webbapp i Azure.
  • JavaScript: Skapa en Node.js webbapp i Azure App Service.
  • Java: Skapa en Java-app i Azure App Service.
  • Python: Skapa en Python-app i Azure App Service.

Skapa en pipeline för din stack

Kodexemplen i det här avsnittet förutsätter att du distribuerar en ASP.NET webbapp. Du kan anpassa instruktionerna för andra ramverk.

Läs mer om stöd för Azure Pipelines-ekosystem.

YAML

1. Logga in på din Azure DevOps-organisation och gå till projektet.

2. Gå till Pipelines och välj Ny pipeline.

3. När du uppmanas till det väljer du platsen för källkoden: antingen Azure Repos Git eller GitHub.

   Du kan omdirigeras till GitHub för att logga in. I så fall anger du dina GitHub-autentiseringsuppgifter.

4. När listan över lagringsplatser visas väljer du din lagringsplats.

5. Du kan omdirigeras till GitHub för att installera Azure Pipelines-appen. I så fall väljer du Godkänn och installera.

6. När fliken Konfigurera visas väljer du ASP.NET Core.

7. När den nya pipelinen visas, ta en titt på YAML-filen för att se vad den gör. När du är klar väljer du Spara och kör.

Klassisk

Så här kommer du i gång:

1. Skapa en pipeline och välj mallen ASP.NET Core . Det här valet lägger automatiskt till de uppgifter som krävs för att bygga koden i exempelarkivet.

2. För att se den i praktiken, spara pipelinen och köa ett bygge.

   Pipelinemallen ASP.NET Core publicerar zip-filen för distribution som en Azure-artefakt för distributionsuppgiften i nästa steg.

2. Lägg till distributionsuppgiften

YAML

1. Välj slutet av YAML-filen och välj sedan Visa assistent.

2. Använd aktivitetsassistenten för att lägga till Azure-webbappsaktiviteten .

   Du kan också lägga till Azure App Service deploy-uppgift AzureRmWebAppDeployment.

3. Välj din Azure-prenumeration. Välj Auktorisera för att auktorisera anslutningen. Auktoriseringen skapar den tjänstanslutning som krävs.

4. Välj stacken Apptyp, Appnamn och Runtime baserat på din App Service-app. Din fullständiga YAML bör se ut ungefär som följande kod.

   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: Namnet på den auktoriserade tjänstanslutningen till din Azure-prenumeration.
   • appName: Namnet på din befintliga app.
   • package: Filsökväg till paketet eller en mapp som innehåller ditt App Service-innehåll. Jokertecken stöds.

Klassisk

Så här kommer du i gång:

1. Skapa en release pipeline. Välj Versioner från menyn till vänster och välj Ny pipeline.

2. Välj Azure App Service-distributionsmallen för din fas. Det här steget lägger automatiskt till nödvändiga uppgifter.

   Anmärkning

   Om du distribuerar en Node.js app till App Service i Windows väljer du mallen Distribuerad Node.js app till Azure App Service . Den enda skillnaden mellan dessa mallar är att Node.js-mallen konfigurerar uppgiften för att generera en web.config fil som innehåller en parameter som startar iisnode tjänsten.

3. För att länka den här versionspipelinen till Azure-artefakten från föregående steg väljer du Lägg till en artefakt>Bygg.

4. I Källa (bygg-pipeline) väljer du den byggpipeline som du skapade i föregående avsnitt. Välj sedan Lägg till.

5. Om du vill se den i praktiken sparar du versionspipelinen och skapar en version.

Exempel: Distribuera en .NET-app

YAML

Om du vill distribuera ett .zip webbpaket (till exempel från en ASP.NET webbapp) till en Azure-webbapp använder du följande kodfragment för att distribuera bygget till en app.

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: Din Azure-prenumeration.
• appType: Typ av webbapp.
• appName: Namnet på din befintliga apptjänst.
• package: Filsökväg till paketet eller en mapp som innehåller ditt App Service-innehåll. Jokertecken stöds.

Klassisk

För klassiska pipelines är det enklare att definiera bygg- och lanseringssteg i separata fönster (pipelines respektive versioner).

• I fönstret Pipelines skapar och testar du din app med valfri mall, till exempel ASP.NET Core, Node.js med Grunt, Maven eller andra. Publicera en artefakt.
• I versionsfönstret använder du den generiska Azure App Service-distributionsmallen för att distribuera artefakten.

Det kan finnas mallar för specifika programmeringsspråk att välja mellan.

Exempel: Distribuera till ett virtuellt program

YAML

Som standard sker distributionen till rotprogrammet i Azure-webbappen. Du kan distribuera till ett specifikt virtuellt program med hjälp VirtualApplication av egenskapen för Azure App Service-distributionsuppgiften AzureRmWebAppDeployment:

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

• VirtualApplication: Namnet på det virtuella programmet som konfigurerats i Azure-portalen. Mer information finns i Konfigurera en App Service-app i Azure Portal .

Klassisk

Som standard sker distributionen till rotprogrammet i Azure-webbappen. Om du vill distribuera till ett specifikt virtuellt program anger du dess namn i egenskapen Virtuellt program för Azure App Service-distributionsaktiviteten.

Exempel: Distribuera till en slot

YAML

I följande exempel visas hur du distribuerar till ett mellanlagringsfack och sedan byter till en produktionsplats:

- 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: Din Azure-prenumeration.
• appType: (Valfritt) Använd webAppLinux för att distribuera till en webbapp i Linux.
• appName: Namnet på din befintliga apptjänst.
• deployToSlotOrASE*:Boolesk. Distribuera till ett befintligt distributionsfack eller Azure App Service-miljön.
• resourceGroupName: Namnet på resursgruppen. Krävs om deployToSlotOrASE är sant.
• slotName: Namnet på platsen, som per standard är production. Krävs om deployToSlotOrASE är sant.
• package: Filsökväg till paketet eller en mapp som innehåller ditt App Service-innehåll. Jokertecken stöds.
• SourceSlot: Plats skickas till produktion om SwapWithProduction är sant.
• SwapWithProduction:Boolesk. Byt trafik mellan källplats och produktion.

Klassisk

Använd alternativet Distribuera till fack eller App Service-miljön i Azure Web App-aktiviteten för att ange det fack som ska distribueras till. Om du vill byta platser använder du Azure App Service Management-uppgiften.

Exempel: Distribuera till flera webbappar

YAML

Du kan använda jobb i YAML-filen för att konfigurera en pipeline med distributioner. Med hjälp av jobb kan du styra distributionsordningen till flera webbappar.

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'

Klassisk

Om du vill distribuera till flera webbappar lägger du till steg i versionspipelinen. Du kan styra distributionsordningen. Mer information finns i Steg.

Exempel: Distribuera villkorligt

YAML

Om du vill distribuera villkorligt i YAML kan du använda någon av följande tekniker:

• Isolera distributionssteget till ett separat jobb och lägg till ett villkor för det jobbet.
• Lägg till ett villkor i steget.

I följande exempel visas hur du använder stegvillkor för att endast distribuera byggen som kommer från huvudgrenen:

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

Mer information om villkor finns i Ange villkor.

Klassisk

I versionspipelinen kan du implementera olika kontroller och villkor för att styra distributionen:

• Ange grenfilter för att konfigurera utlösare för kontinuerlig distribution på artefakten till distributionspipelinen.
• Ange godkännanden före distributionen eller konfigurera portar som en förutsättning för distribution till en fas.
• Ange villkor för en aktivitet som ska köras.

Mer information finns i Versionshantering för utlösare, grenar och faser, Distributionshantering för version med godkännanden, Distributionshantering med portar och Ange villkor för att köra en uppgift.

Exempel: Distribuera med webbdistribution

Azure App Service-distributionsuppgiften AzureRmWebAppDeployment kan distribueras till App Service med hjälp av Webbdistribution.

YAML

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'

Klassisk

Om du använder Azure App Service-distributionsmallen i versionspipelinen:

1. Välj fliken Uppgifter och välj sedan Distribuera Azure App Service (uppgiften AzureRmWebAppDeployment ).

2. I dialogrutan kontrollerar du att Anslutningstyp är inställd på Azure Resource Manager.

3. I dialogrutan expanderar du Ytterligare distributionsalternativ och väljer Välj distributionsmetod. Kontrollera att Webbdistribution har valts som distributionsmetod.

4. Spara utgivningspipen.

Anmärkning

Med uppgifterna AzureRmWebAppDeployment@3 och AzureRmWebAppDeployment@4 bör du använda anslutningstypen Azure Resource Manager eller AzureRM när du distribuerar med Web Deploy. Den använder publiceringsprofiler för distribution när grundläggande autentisering är aktiverad för din app. När grundläggande autentisering är inaktiverad använder den säkrare Microsoft Entra-ID-autentisering.

Vanliga frågor och svar

Vad är skillnaden mellan aktiviteterna AzureWebApp och AzureRmWebAppDeployment ?

Azure Web App-uppgiftenAzureWebApp är det enklaste sättet att distribuera till en Azure-webbapp. Som standard sker distributionen till rotprogrammet i Azure-webbappen.

Azure App Service Deploy-uppgiften (AzureRmWebAppDeployment) kan hantera fler anpassade scenarier, till exempel:

• Distribuera med Web Deploy, om du vanligtvis använder IIS-distributionsprocessen (Internet Information Services).
• Distribuera till virtuella applikationer.
• Distribuera till andra apptyper, till exempel containerappar, funktionsappar, webbjobb eller API och mobilappar.

Anmärkning

Den separata filtransformeringsaktiviteten stöder även filtransformering och variabel ersättning för användning i Azure Pipelines. Du kan använda filtransformeringsaktiviteten för att tillämpa filtransformeringar och variabelersättningar på alla konfigurations- och parameterfiler.

Varför visas meddelandet "Ogiltig App Service-paket eller mappsökväg har angetts"?

Beroende på din pipeline i YAML-pipelines kan det finnas ett matchningsfel mellan var det skapade webbpaketet sparas och var distributionsuppgiften letar efter det. Till exempel hämtar uppgiften AzureWebApp webbpaketet för distribution. Uppgiften AzureWebApp kan se ut i $(System.DefaultWorkingDirectory)/**/*.zip. Om webbpaketet deponeras på annan plats ändrar du värdet för package.

Varför får jag meddelandet "Publicera med webdeploy-alternativ stöds endast när jag använder Windows-agenten"?

Det här felet uppstår i AzureRmWebAppDeployment uppgiften när du konfigurerar uppgiften att distribuera med hjälp av Webbdistribution, men din agent kör inte Windows. Kontrollera att YAML innehåller något som liknar följande kod:

pool:
  vmImage: windows-latest

Varför fungerar inte webbdistribution när jag inaktiverar grundläggande autentisering?

Felsökningsinformation om hur du får Microsoft Entra-ID-autentisering att fungera med AzureRmWebAppDeployment uppgiften finns i Jag kan inte webbdistribuera till min Azure App Service med Microsoft Entra ID-autentisering från min Windows-agent.

Relaterat innehåll

• Anpassa din Azure DevOps-pipeline.