Dela via


Distribuera till App Service med Azure Pipelines

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

Kommentar

Från och med den 1 juni 2024 har alla nyligen skapade App Service-appar möjlighet att generera ett unikt standardvärdnamn med hjälp av namngivningskonventionen <app-name>-<random-hash>.<region>.azurewebsites.net. Befintliga appnamn förblir oförändrade.

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

Mer information finns i Unikt standardvärdnamn för App Service-resurs.

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

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.

  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.

2. Lägg till distributionsuppgiften

  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 .

    Skärmbild av Azure-webbappens uppgift.

    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:
    - 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.

Exempel: Distribuera en .NET-app

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: 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.

Exempel: distribuera till ett virtuellt program

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

Exempel: Distribuera till ett fack

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 Environment.
  • 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.

Exempel: Distribuera till flera webbappar

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'

Exempel: Gör variabelersättningar

För de flesta språkstackar kan appinställningar och niska veze 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 niska veze 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.

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

Exempel: Distribuera villkorligt

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.

Exempel: distribuera med webbdistribution

Azure App Service-distributionsuppgiften (AzureRmWebAppDeployment) kan distribueras till App Service med hjälp av webbdistribution.

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'

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:

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