Distribuera till App Service med Azure Pipelines

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.

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.

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

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.

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.

För klassiska pipelines är det enklast att definiera bygg- och versionssteg på separata sidor (pipelines respektive 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.

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 .

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.

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.

Använd alternativet Distribuera till plats eller App Service-miljö 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.

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'

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

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

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.

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.

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.

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'

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