Implementeren in Azure App Service met behulp van Azure Pipelines

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

Gebruik Azure Pipelines om uw web-app automatisch te implementeren in Azure-app Service bij elke geslaagde build. Met Azure Pipelines kunt u met behulp van Azure DevOps bouwen, testen en implementeren met continue integratie en continue levering (CI/CD).

YAML-pijplijnen worden gedefinieerd met behulp van een YAML-bestand in uw opslagplaats. Een stap is de kleinste bouwsteen van een pijplijn en kan een script of taak (vooraf verpakt script) zijn. Meer informatie over de belangrijkste concepten en onderdelen waaruit een pijplijn bestaat.

U gebruikt de Azure Web App-taak (AzureWebApp) om naar Azure App Service te deployen binnen uw pipeline. Voor complexere scenario's, zoals wanneer u XML-parameters in uw implementatie moet gebruiken, kunt u de Azure App Service-implementatietaak AzureRmWebAppDeploymentgebruiken.

Voorwaarden:

• Een Azure-account met een actief abonnement. Gratis een account maken
• een Azure DevOps-organisatie. Maak gratis een account.
• De mogelijkheid om pipelines uit te voeren op door Microsoft gehuisveste agents. U kunt een parallelle taak aanschaffen of een gratis laag aanvragen.
• Een werkende Azure App Service-app met de code die wordt gehost op GitHub of Azure-opslagplaatsen.
  • .NET: Maak een ASP.NET Core-web-app in Azure.
  • ASP.NET: Maak een ASP.NET Framework-web-app in Azure.
  • JavaScript: Een Node.js-web-app maken in Azure App Service.
  • Java: Een Java-app maken in Azure App Service.
  • Python: Een Python-app maken in Azure App Service.

1. Een pijplijn voor uw stack maken

In de codevoorbeelden in deze sectie wordt ervan uitgegaan dat u een ASP.NET-web-app implementeert. U kunt de instructies voor andere frameworks aanpassen.

Meer informatie over azure Pipelines-ecosysteemondersteuning.

YAML

1. Meld u aan bij uw Azure DevOps-organisatie en ga naar uw project.

2. Ga naar Pijplijnen en selecteer Nieuwe pijplijn.

3. Wanneer u hierom wordt gevraagd, selecteert u de locatie van uw broncode: Azure Repos Git of GitHub.

   U wordt mogelijk omgeleid naar GitHub om u aan te melden. Voer in dat geval uw GitHub-referenties in.

4. Wanneer de lijst met opslagplaatsen wordt weergegeven, selecteert u uw opslagplaats.

5. U wordt mogelijk omgeleid naar GitHub om de Azure Pipelines-app te installeren. Als dat het zo is, selecteert u Goedkeuren en installeren.

6. Wanneer het tabblad Configureren wordt weergegeven, selecteert u ASP.NET Core.

7. Wanneer uw nieuwe pijplijn wordt weergegeven, bekijkt u de YAML om te zien wat deze doet. Wanneer u klaar bent, selecteert u Opslaan en uitvoeren.

Klassiek

Ga als volgt aan de slag:

1. Maak een pijplijn en selecteer de ASP.NET Core-sjabloon . Met deze selectie worden automatisch de taken toegevoegd die nodig zijn om de code in de voorbeeldopslagplaats te bouwen.

2. Als u deze in actie wilt zien, slaat u de pijplijn op en voegt u een build toe aan de wachtrij.

   De ASP.NET Core-pijplijnsjabloon publiceert het ZIP-implementatiebestand als een Azure-artefact voor de implementatietaak in de volgende stap.

2. De implementatietaak toevoegen

YAML

1. Selecteer het einde van het YAML-bestand en selecteer vervolgens Assistent tonen.

2. Gebruik de Taakassistent om de taak van de Azure-web-app toe te voegen.

   U kunt ook de Azure App Service-implementatietaak AzureRmWebAppDeployment toevoegen.

3. Kies uw Azure-abonnement. Zorg ervoor dat u Autoriseren selecteert om uw verbinding te autoriseren. De autorisatie creëert de vereiste serviceverbinding.

4. Selecteer het app-type, de app-naam en de runtimestack op basis van uw App Service-app. Uw volledige YAML moet er ongeveer uitzien als de volgende code.

   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: Naam van de geautoriseerde serviceverbinding met uw Azure-abonnement.
   • appName: Naam van uw bestaande app.
   • package: Bestandspad naar het pakket of een map met uw App Service-inhoud. Wildcards worden ondersteund.

Klassiek

Ga als volgt aan de slag:

1. Maak een release-pijplijn. Selecteer Releases in het linkermenu en selecteer Nieuwe pijplijn.

2. Selecteer de Azure-app Service-implementatiesjabloon voor uw fase. Met deze stap worden automatisch de benodigde taken toegevoegd.

   Notitie

   Als u een Node.js-app implementeert in App Service in Windows, selecteert u de sjabloon Geïmplementeerd Node.js-app in Azure App Service . Het enige verschil tussen deze sjablonen is dat de Node.js-sjabloon de taak configureert om een web.config bestand te genereren dat een parameter bevat waarmee de iisnode service wordt gestart.

3. Als u deze releasepijplijn wilt koppelen aan het Azure-artefact uit de vorige stap, selecteert u Een artefact toevoegen>Build.

4. Selecteer in Bron (build-pijplijn) de build-pijplijn die u in de vorige sectie hebt gemaakt. Selecteer vervolgens Toevoegen.

5. Als u het in actie wilt zien, sla dan de release pipeline op en maak een release.

Voorbeeld: Een .NET-app implementeren

YAML

Als u een .zip-webpakket (bijvoorbeeld van een ASP.NET-web-app) naar een Azure-web-app wilt implementeren, gebruikt u het volgende codefragment om de build te implementeren in een 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: uw Azure-abonnement.
• appType: uw webapp-type.
• appName: De naam van uw bestaande app-service.
• package: Bestandspad naar het pakket of een map met uw App Service-inhoud. Wildcards worden ondersteund.

Klassiek

Voor klassieke pijplijnen is het eenvoudiger om build- en releasefasen te definiëren in afzonderlijke deelvensters (pijplijnen en releases).

• Bouw en test uw app in het deelvenster Pijplijnen met behulp van de sjabloon van uw keuze, zoals ASP.NET Core, Node.js met Grunt, Maven of anderen. Een artefact publiceren.
• Gebruik in het deelvenster Release de algemene Azure App Service-implementatiesjabloon om het artefact te implementeren.

Er zijn mogelijk sjablonen voor specifieke programmeertalen waaruit u kunt kiezen.

Voorbeeld: Implementeren in een virtuele toepassing

YAML

Uw implementatie gebeurt standaard met de hoofdtoepassing in de Azure-web-app. U kunt implementeren in een specifieke virtuele toepassing met behulp van de VirtualApplication eigenschap van de Azure App Service-implementatietaak AzureRmWebAppDeployment:

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

• VirtualApplication: De naam van de virtuele toepassing die is geconfigureerd in Azure Portal. Zie Een App Service-app configureren in Azure Portal voor meer informatie.

Klassiek

Uw implementatie gebeurt standaard met de hoofdtoepassing in de Azure-web-app. Als u wilt implementeren naar een specifieke virtuele toepassing, voert u de naam in de eigenschap Virtuele toepassing van de Azure-app Service-implementatietaak in.

Voorbeeld: Implementeren in een slot

YAML

In het volgende voorbeeld ziet u hoe u implementeert in een staging-slot en vervolgens wisselt naar een productie-slot.

- 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: uw Azure-abonnement.
• appType: (Optioneel) Gebruiken webAppLinux om te implementeren in een web-app in Linux.
• appName: De naam van uw bestaande app-service.
• deployToSlotOrASE*:Booleaans. Implementeer naar een bestaand implementatieslot of Azure App Service Environment.
• resourceGroupName: Naam van de resourcegroep. Vereist als deployToSlotOrASE waar is.
• slotName: Naam van de slot, dat standaard production is. Vereist als deployToSlotOrASE waar is.
• package: Bestandspad naar het pakket of een map met uw App Service-inhoud. Wildcards worden ondersteund.
• SourceSlot: Slot naar productie verzonden wanneer SwapWithProduction waar is.
• SwapWithProduction:Booleaans. Het verkeer van de bronplaats wisselen met de productieplaats.

Klassiek

Gebruik de optie Implementeren naar Slot of App Service Environment in de Azure-web-app-taak om het slot op te geven waarnaar moet worden geïmplementeerd. Als u de slots wilt wisselen, gebruikt u de Azure App Service beheren taak.

Voorbeeld: Implementeren in meerdere web-apps

YAML

U kunt taken in uw YAML-bestand gebruiken om een pijplijn met implementaties in te stellen. Met behulp van taken kunt u de volgorde van implementatie in meerdere web-apps beheren.

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'

Klassiek

Als u wilt implementeren in meerdere web-apps, voegt u fasen toe aan uw release-pijplijn. U kunt de volgorde van de implementatie beheren. Zie Fasen voor meer informatie.

Voorbeeld: Voorwaardelijk implementeren

YAML

Als u voorwaardelijk wilt implementeren in YAML, kunt u een van de volgende technieken gebruiken:

• Isoleer de implementatiestappen in een afzonderlijke taak en voeg een voorwaarde toe aan die taak.
• Voeg een voorwaarde toe aan de stap.

In het volgende voorbeeld ziet u hoe u stapvoorwaarden gebruikt om alleen builds te implementeren die afkomstig zijn van de hoofdbranch:

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

Voor meer informatie over voorwaarden, zie Voorwaarden specificeren.

Klassiek

In uw release-pijplijn kunt u verschillende controles en voorwaarden implementeren om de implementatie te beheren:

• Stel vertakkingsfilters in om de trigger voor continue implementatie te configureren op het artefact van de release-pijplijn.
• Stel goedkeuringen vóór de implementatie in of configureer poorten als voorwaarde voor implementatie naar een fase.
• Geef voorwaarden op voor het uitvoeren van een taak.

Zie Release-, vertakkings- en fasetriggers, Release-implementatiebeheer met behulp van goedkeuringen, Release-implementatiebeheer met behulp van poorten en Voorwaarden opgeven voor het uitvoeren van een taak voor meer informatie.

Voorbeeld: Implementeren met behulp van Web Deploy

De Azure App Service-implementatietaak AzureRmWebAppDeployment kan worden geïmplementeerd in App Service met behulp van Web Deploy.

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'

Klassiek

Als u de Azure App Service-implementatiesjabloon in de release-pijplijn gebruikt:

1. Selecteer het tabblad Taken en selecteer vervolgens Azure App Service implementeren (de AzureRmWebAppDeployment taak).

2. Zorg ervoor dat het verbindingstype is ingesteld op Azure Resource Manager in het dialoogvenster.

3. Vouw in het dialoogvenster Aanvullende implementatieopties uit en kies Implementatiemethode selecteren. Zorg ervoor dat Web Deploy is geselecteerd als de implementatiemethode.

4. Sla de release-pijplijn op.

Notitie

Met de AzureRmWebAppDeployment@3 en AzureRmWebAppDeployment@4 taken moet u het verbindingstype Azure Resource Manager gebruiken of AzureRM wanneer u implementeert met Web Deploy. Het maakt gebruik van publicatieprofielen voor implementatie wanneer basisverificatie is ingeschakeld voor uw app. Wanneer basisverificatie is uitgeschakeld, wordt gebruikgemaakt van de veiligere Microsoft Entra ID-verificatie.

Veelgestelde vragen

Wat is het verschil tussen de AzureWebApp-taken en AzureRmWebAppDeployment-taken?

De Azure-web-app-taakAzureWebApp is de eenvoudigste manier om te implementeren in een Azure-web-app. Uw implementatie gebeurt standaard met de hoofdtoepassing in de Azure-web-app.

De Azure-app Service Deploy-taak (AzureRmWebAppDeployment) kan meer aangepaste scenario's verwerken, zoals:

• Implementeren met Web Deploy, als u meestal het IIS-implementatieproces (Internet Information Services) gebruikt.
• Implementeren in virtuele toepassingen.
• Implementeren naar andere app-typen, zoals container-apps, functie-apps, WebJobs of API en mobiele apps.

Notitie

De afzonderlijke taak Bestandstransformatie ondersteunt ook bestandstransformaties en het vervangen van variabelen voor gebruik in Azure Pipelines. U kunt de taak Bestandstransformatie gebruiken om bestandstransformaties en variabele vervangingen toe te passen op configuratie- en parameterbestanden.

Waarom krijg ik het bericht 'Ongeldig App Service-pakket of mappad opgegeven'?

Afhankelijk van uw pijplijn komen er in YAML-pijplijnen mogelijk niet overeen tussen waar uw ingebouwde webpakket wordt opgeslagen en waar de implementatietaak ernaar op zoek is. De AzureWebApp taak pakt bijvoorbeeld het webpakket op voor implementatie. De AzureWebApp taak kan er uitzien in $(System.DefaultWorkingDirectory)/**/*.zip. Als het webpakket ergens anders wordt neergezet, wijzigt u de waarde van package.

Waarom krijg ik het bericht 'Publiceren met webdeploy-opties worden alleen ondersteund bij het gebruik van windows-agent'?

Deze fout treedt op in de AzureRmWebAppDeployment taak wanneer u de taak configureert om te implementeren met Web Deploy, maar uw agent draait niet op Windows. Controleer of uw YAML iets bevat dat lijkt op de volgende code:

pool:
  vmImage: windows-latest

Waarom werkt Web Deploy niet wanneer ik basisverificatie uitschakelt?

Zie voor informatie over het oplossen van problemen bij het verkrijgen van Microsoft Entra ID-verificatie die werkt met de AzureRmWebAppDeployment taak, Ik kan mijn Azure App Service niet via Web Deploy gebruiken met Microsoft Entra ID-verificatie vanaf mijn Windows-agent.

Verwante inhoud

• Pas uw Azure DevOps-pijplijn aan.