Distribuera till App Service med 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 (CI) och kontinuerlig leverans (CD) med Hjälp av Azure DevOps.

YAML-pipelines definieras med hjälp av en YAML-fil på lagringsplatsen. 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-uppgiften (AzureWebApp) för att distribuera till Azure App Service i din pipeline. Om du vill ha mer komplicerade scenarier som att behöva 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 Azure DevOps-organisation. Skapa en kostnadsfritt.
• En möjlighet att köra pipelines på Microsoft-värdbaserade agenter. Du kan antingen köpa ett parallellt jobb eller begära en kostnadsfri nivå.
• En fungerande Azure App Service-app med kod 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

1. 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 sedan 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 tar du en titt på YAML 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 . Den här markeringen lägger automatiskt till de uppgifter som krävs för att skapa koden i exempellagringsplatsen.

2. Spara pipelinen och köa en version för att se den i praktiken.

   Mallen ASP.NET Core-pipeline publicerar ZIP-distributionsfilen som en Azure-artefakt för distributionsaktiviteten senare.

2. Lägg till distributionsuppgiften

YAML

1. Klicka på slutet av YAML-filen och välj sedan Visa assistent."

2. Använd aktivitetsassistenten för att lägga till Azure Web App-aktiviteten .

   

   Du kan också lägga till uppgiften Azure App Service Deploy (AzureRmWebAppDeployment).

3. Välj din Azure-prenumeration. Se till 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:
   - 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: 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 innehållet i apptjänsten. Jokertecken stöds.

Klassisk

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

1. Skapa en versionspipeline genom att välja Versioner på den vänstra menyn och välja Ny pipeline.

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

   Kommentar

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

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

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

5. Spara versionspipelinen och skapa en version för att se den i praktiken.

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:
- 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: din Azure-prenumeration.
• appType: din webbappstyp.
• appName: namnet på din befintliga apptjänst.
• package: filsökvägen till paketet eller en mapp som innehåller innehållet i apptjänsten. Jokertecken stöds.

Klassisk

För klassiska pipelines är det enklast att definiera bygg- och versionssteg på separata sidor (pipelinesrespektive versioner). I allmänhet:

• På sidan Pipelines skapar och testar du appen med valfri mall, till exempel ASP.NET Core, Node.js med Grunt, Maven eller andra, och publicerar en artefakt.
• På sidan Version 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 program som har konfigurerats i Azure-portalen. Mer information finns i Konfigurera en App Service-app i Azure-portalen .

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 ett fack

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: Booleskt. Distribuera till ett befintligt distributionsfack eller Azure App Service-miljön.
• resourceGroupName: Namnet på resursgruppen. Krävs om deployToSlotOrASE är sant.
• slotName: Namnet på facket, som standard är production. Krävs om deployToSlotOrASE är sant.
• package: filsökvägen till paketet eller en mapp som innehåller innehållet i apptjänsten. Jokertecken stöds.
• SourceSlot: Fack som skickas till produktion när SwapWithProduction är sant.
• SwapWithProduction: Booleskt värde. Växla trafik från källplatsen med 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 fack använder du Azure App Service-hanteringsuppgiften.

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: Gör variabelersättningar

För de flesta språkstackar kan appinställningar och anslutningssträng anges som miljövariabler vid körning.

Men det finns andra orsaker till att du vill göra variabelersättningar till web.config. I det här exemplet innehåller filen Web.config en anslutningssträng med namnet connectionString. Du kan ändra dess värde innan du distribuerar till varje webbapp. Du kan göra detta antingen genom att använda en Web.config-transformering eller genom att ersätta variabler i web.config-filen.

YAML

Följande kodfragment visar ett exempel på variabelersättning med hjälp av Azure App Service Deploy(AzureRmWebAppDeployment)-uppgiften:

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

Klassisk

Så här ändrar connectionString du med hjälp av variabelersättning:

1. Skapa en versionspipeline med två steg.
2. Länka versionens artefakt till den version som skapar webbpaketet.
3. Definiera connectionString som en variabel i vart och ett av stegen. Ange lämpligt värde.
4. Välj alternativet XML-variabelersättning under Filtransformering och Alternativ för variabelersättning för Azure App Service Deploy-uppgiften.

Exempel: Distribuera villkorligt

YAML

Om du vill göra detta i YAML kan du använda någon av följande tekniker:

• Isolera distributionsstegen till ett separat jobb och lägg till ett villkor i 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ösaren för kontinuerlig distribution på artefakten i versionspipelinen.
• Ange godkännanden före distributionen som en förutsättning för distribution till en fas.
• 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 Utlösare för versions-, gren- och faser, Distributionskontroll för version med godkännanden, Versionsdistributionskontroll med hjälp av 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:
- 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'

Klassisk

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

1. Välj fliken Uppgifter och välj sedan Distribuera Azure App Service. Det här är uppgiften AzureRmWebAppDeployment .

2. I dialogrutan kontrollerar du att Anslut ionstypen ä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 versionspipelinen.

Kommentar

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

Vanliga frågor och svar

Vad är skillnaden mellan aktiviteterna AzureWebApp och AzureRmWebAppDeployment ?

Azure Web App-uppgiften (AzureWebApp) ä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:

• Ändra konfigurationsinställningarna i webbpaket och XML-parameterfiler.
• Distribuera med Web Deploy om du är van vid IIS-distributionsprocessen.
• Distribuera till virtuella program.
• Distribuera till andra apptyper, till exempel containerappar, funktionsappar, webbjobb eller API och mobilappar.

Kommentar

Filtransformeringar och variabelersättning stöds också av den separata filtransformeringsaktiviteten 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.

Jag får meddelandet "Ogiltig App Service-paket eller mappsökväg tillhandahålls".

Beroende på din pipeline i YAML-pipelines kan det finnas ett matchningsfel mellan var det skapade webbpaketet sparas och var distributionsuppgiften letar efter det. Uppgiften hämtar till exempel AzureWebApp webbpaketet för distribution. AzureWebApp-aktiviteten ser till exempel ut i $(System.DefaultWorkingDirectory)/**/*.zip. Om webbpaketet deponeras någon annanstans ändrar du värdet packageför .

Jag får meddelandet "Publicera med webdeploy-alternativ stöds endast när du 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 DIN YAML har något som liknar följande kod:

pool:
  vmImage: windows-latest

Webbdistribution fungerar inte 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

Nästa steg

• Anpassa din Azure DevOps-pipeline.