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

Definiera en pipeline genom att skapa en azure-pipelines.yml YAML-fil i kodlagringsplatsen.

1. På den vänstra navigeringsmenyn för ditt Azure DevOps-projekt väljer du Pipelines.
2. På sidan Pipelines väljer du Ny pipeline eller Skapa pipeline om den här pipelinen är den första i projektet.
3. På skärmen Var är din kod väljer du platsen för källkoden, antingen Azure Repos Git eller GitHub. Om det behövs loggar du in på GitHub.
4. På skärmen Välj en lagringsplats väljer du din kodlagringsplats.
5. På skärmen Konfigurera pipeline väljer du Startpipeline.

Lägg till uppgiften .NET Core (DotNetCoreCLI@2) i pipelinen och skapa och publicera din app.

1. På skärmen Granska yaml-pipelinen tar du bort all kod efter steps: raden.
2. Välj slutet av filen och välj sedan Visa assistent till höger.
3. Under Uppgifter väljer du .NET Core.
4. På konfigurationsskärmen för .NET Core går du till Azure Resource Manager-anslutningen, väljer din Azure-prenumeration och väljer sedan Auktorisera för att skapa den tjänstanslutning som krävs.
5. Under Kommando väljer du Publicera.
6. Kontrollera att kryssrutorna Publicera webbprojekt och Zip-publicerade projekt är markerade och välj sedan Lägg till.
7. Uppgiften visas i YAML-pipelinen. Granska YAML-koden för att se vad den gör. När du är klar väljer du Spara och kör och väljer sedan Spara och kör igen.
8. På skärmen Build Summary (Skapa sammanfattning ) under Jobb väljer du länken Behörighet som behövs . På skärmen Kontroller väljer du Tillåt och sedan Tillåt igen. Om du beviljar behörighet här kan du använda tjänstanslutningen som du har auktoriserat för alla körningar av den här pipelinen.

1. På den vänstra navigeringsmenyn för ditt Azure DevOps-projekt väljer du Pipelines.
2. På sidan Pipelines väljer du Ny pipeline eller Skapa pipeline om den här pipelinen är den första i projektet.
3. På skärmen Var är din kod väljer du Använd den klassiska redigeraren för att skapa en pipeline utan YAML.
4. På skärmen Välj en lagringsplats väljer du platsen för din källkod, antingen Azure Repos Git eller GitHub, och väljer sedan din kodlagringsplats och standardgren. Välj Fortsätt.
5. På skärmen Välj en mall väljer du ASP.NET Core och sedan Använd.
6. På den nya pipelineskärmen, under Agentspecifikation till höger, väljer du en agentspecifikation, till exempel ubuntu-latest eller windows-latest beroende på din appplattform och version.
7. Titta på pipelinen för att se vad den gör. När du är klar väljer du Spara och kö.
8. Välj Spara & kö igen och välj Spara och kör på skärmen Kör pipeline.

1. På skärmen Sammanfattning för pipelinekörning väljer du ikonen Fler åtgärder uppe till höger och väljer sedan Redigera pipeline.
2. Välj slutet av YAML-filen och välj Visa assistent om listan Uppgifter inte visas.
3. I listan Uppgifter söker du efter och väljer Azure Web App-aktiviteten . Du kan också använda Azure App Service-distributionsuppgiften .
4. På konfigurationsskärmen för Azure Web App går du till Azure-prenumerationen och väljer samma tjänstanslutning som du konfigurerade för föregående steg. Du behöver inte auktorisera anslutningen igen.
5. För Apptyp väljer du Azure Web App på Linux eller Azure Web App i Windows, beroende på din kod.
6. Som Appnamn väljer eller anger du appnamnet för App Service.
7. Välj Lägg till.
8. Välj Verifiera och spara och välj sedan Spara.
9. Välj Kör och välj sedan Kör igen.

Den fullständiga YAML-pipelinen bör se ut som följande kod:

trigger:
- <branch-specification>

pool:
  vmImage: <agent-specification>

steps:
- task: DotNetCoreCLI@2
  inputs:
    azureSubscription: '<your-authorized-service-connection>'
    command: 'publish'
    publishWebProjects: true

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<your-authorized-service-connection>'
    appType: 'webApp'
    appName: '<your-app-name>'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'
    deploymentMethod: 'auto'  

• azureSubscription: Namnet på den auktoriserade tjänstanslutningen till din Azure-prenumeration.
• appName: Namnet på din befintliga app.
• package: Filsökväg till paketet eller mappen som innehåller ditt App Service-innehåll. Jokertecken stöds.

För klassiska pipelines är det enklast att definiera bygg- och versionssteg i separata pipelines.

1. På den vänstra navigeringsmenynför projektet väljer du> och sedan Ny pipeline för att skapa en versionspipeline.

2. Under Välj en mall väljer du azure App Service-distributionsmallen och väljer Tillämpa. Den här mallen 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 Distribuera en Node.js app till Azure App Service . Den här mallen konfigurerar uppgiften för att generera en web.config fil som innehåller en parameter som startar iisnode tjänsten.

3. På sidan Ny versionspipeline väljer du fliken Uppgifter , väljer Steg 1 och slutför följande fält under Parametrar:

   • Azure-prenumeration: Om du inte redan har en Azure-tjänstanslutning väljer du din Azure-prenumeration och väljer sedan Auktorisera för att skapa den tjänstanslutning som krävs.
   • Apptyp: Välj Azure Web App i Linux eller Azure Web App i Windows för att matcha din kod och agentspecifikation.
   • Apptjänstnamn: Välj din App Service-app.

4. På fliken Pipeline på skärmen Ny versionspipeline bredvid Artefakter väljer du Lägg till.

5. På skärmen Lägg till en artefakt kontrollerar du att Build är valt och under Källa (bygg-pipeline) väljer du den pipeline som du skapade i föregående avsnitt.

6. Välj Lägg till.

7. På pipelinesidan väljer du Spara uppe till höger och sedan OK.

8. Om du vill köra pipelinen väljer du Skapa version på pipelinesidan och sedan Skapa.

Azure Web App-uppgiften distribueras 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 .

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

VirtualApplication är namnet på det virtuella programmet som konfigurerats i Azure-portalen. Mer information finns i Konfigurera en App Service-app i Azure-portalen.

Azure Web App-uppgiften distribueras till rotprogrammet i Azure-webbappen. Om du vill distribuera till ett specifikt virtuellt program anger du namnet på den virtuella programegenskapen för Azure App Service-distributionsuppgiften .

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>'
    WebAppName: '<app-name>'
    ResourceGroupName: '<name of resource group>'
    SourceSlot: staging
    SwapWithProduction: true

• azureSubscription: Din Azure-tjänstanslutning.
• appType: Valfri apptyp som webAppLinux att distribuera till en webbapp i Linux.
• appName: Namnet på din befintliga app.
• deployToSlotOrASE:Boolesk. Om du vill distribuera till ett befintligt distributionsfack eller En App Service-miljö.
• resourceGroupName: Namnet på resursgruppen som ska distribueras till, obligatoriskt om deployToSlotOrASE det är sant.
• slotName: Namnet på platsen som ska distribueras till, krävs om deployToSlotOrASE det är sant. Standardinställningen är production.
• package: Filsökväg till paketet eller mappen som innehåller appens innehåll. Jokertecken stöds.
• SourceSlot: Plats skickas till produktion om SwapWithProduction är sant.
• SwapWithProduction:Boolesk. Om du vill växla trafik från källplatsen till produktion.

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.

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.

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

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

I följande exempel visas hur du använder stegvillkor för att endast distribuera lyckade versioner 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ö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 följande artiklar:

• Klassiska versionsutlösare
• Distributionskontroll med godkännanden
• Begrepp för distributionsportar

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@5
  inputs:
    ConnectionType: 'AzureRM'
    azureSubscription: '<service-connection-name>'
    appType: 'webApp'
    WebAppName: '<app-name>'
    packageForLinux: '$(System.DefaultWorkingDirectory)/**/*.zip'
    enableCustomDeployment: true
    DeploymentType: 'webDeploy'

Om du använder Azure App Service-distributionsmallen i en versionspipeline följer du de här stegen för att distribuera till webbdistribution.

1. Välj fliken Uppgifter och välj sedan Distribuera Azure App Service, azure App Service-distributionsaktiviteten .
2. På konfigurationsskärmen kontrollerar du att Anslutningstyp är inställd på Azure Resource Manager.
3. Expandera Ytterligare distributionsalternativ och välj Välj distributionsmetod. Kontrollera att Webbdistribution har valts som distributionsmetod.
4. Spara utgivningspipen.