Implementeren in Azure App Service met behulp van Azure Pipelines

Definieer een pijplijn door een AZURE-PIPELINES.YML YAML-bestand te maken in uw codeopslagplaats.

1. Selecteer Pijplijnen in het linkernavigatiemenu voor uw Azure DevOps-project.
2. Selecteer op de pagina Pijplijnende optie Nieuwe pijplijn of Pijplijn maken als deze pijplijn de eerste is in het project.
3. Selecteer in het scherm Waar is uw code de locatie van uw broncode, Ofwel Azure Repos Git of GitHub. Meld u indien nodig aan bij GitHub.
4. Selecteer uw codeopslagplaats in het scherm Een opslagplaats selecteren.
5. Selecteer Starter-pijplijn in het scherm Uw pijplijn configureren.

Voeg de taak .NET Core (DotNetCoreCLI@2) toe aan de pijplijn en bouw en publiceer uw app.

1. Verwijder in het scherm Uw pijplijn YAML controleren alle code na de steps: regel.
2. Selecteer het einde van het bestand en selecteer vervolgens Assistent weergeven aan de rechterkant.
3. Selecteer onder Taken.NET Core.
4. Selecteer in het scherm .NET Core-configuratie onder Azure Resource Manager-verbinding uw Azure-abonnement en selecteer autoriseren om de vereiste serviceverbinding te maken.
5. Selecteer onder Opdrachtpubliceren.
6. Zorg ervoor dat de selectievakjes Webprojecten publiceren en Gepubliceerde zip-projecten zijn ingeschakeld en selecteer vervolgens Toevoegen.
7. De taak wordt weergegeven in uw YAML-pijplijn. Controleer de YAML-code om te zien wat deze doet. Wanneer u klaar bent, selecteert u Opslaan en uitvoeren en selecteert u Opslaan en opnieuw uitvoeren .
8. Selecteer in het scherm Samenvatting samenstellen onder Taken de koppeling Machtigingen die nodig is . Selecteer In het scherm Controlesde optie Toestaan en selecteer Vervolgens opnieuw Toestaan . Als u hier toestemming verleent, wordt het gebruik van de serviceverbinding die u hebt geautoriseerd voor alle uitvoeringen van deze pijplijn toegestaan.

1. Selecteer Pijplijnen in het linkernavigatiemenu voor uw Azure DevOps-project.
2. Selecteer op de pagina Pijplijnende optie Nieuwe pijplijn of Pijplijn maken als deze pijplijn de eerste is in het project.
3. Selecteer in het scherm Waar is uw codede klassieke editor gebruiken om een pijplijn te maken zonder YAML.
4. Selecteer in het scherm Een opslagplaats selecteren de locatie van uw broncode, Git of GitHub voor Azure-opslagplaatsen en selecteer vervolgens uw codeopslagplaats en standaardvertakking. Klik op Doorgaan.
5. Selecteer in het scherm Een sjabloon kiezenASP.NET Core en selecteer vervolgens Toepassen.
6. Selecteer in het scherm nieuwe pijplijn onder Agentspecificatie aan de rechterkant een agentspecificatie, zoals ubuntu-latest of windows-latest, afhankelijk van uw app-platform en -versie.
7. Bekijk de pijplijn om te zien wat deze doet. Wanneer u klaar bent, selecteert u Opslaan en wachtrij.
8. Selecteer Opslaan en wachtrij opnieuw en selecteer opslaan en uitvoeren in het scherm Pijplijn uitvoeren.

1. Selecteer in het scherm Samenvatting van pijplijnuitvoering het pictogram Meer acties in de rechterbovenhoek en selecteer vervolgens Pijplijn bewerken.
2. Selecteer het einde van het YAML-bestand en selecteer Assistent weergevenals de takenlijst niet wordt weergegeven.
3. Zoek en selecteer de Azure Web App-taak in de lijst Taken. U kunt ook de Azure App Service-implementatietaak gebruiken.
4. Selecteer in het scherm configuratie van De Azure-web-app onder Azure-abonnement dezelfde serviceverbinding die u voor de vorige stap hebt ingesteld. U hoeft deze verbinding niet opnieuw te autoriseren.
5. Voor app-type selecteert u Azure Web App in Linux of Azure Web App in Windows, afhankelijk van uw code.
6. Selecteer of voer uw App Service-app-naam in als app-naam.
7. Selecteer Toevoegen.
8. Selecteer Valideren en opslaan en selecteer Vervolgens Opslaan.
9. Selecteer Uitvoeren en selecteer vervolgens Opnieuw uitvoeren .

De volledige YAML-pijplijn moet eruitzien als de volgende code:

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

Voor klassieke pijplijnen is het het eenvoudigst om build- en releasefasen in afzonderlijke pijplijnen te definiëren.

1. Selecteer in het linkernavigatiemenu voor uw project pijplijnenreleases> en selecteer vervolgens Nieuwe pijplijn om een release-pijplijn te maken.

2. Selecteer onder Selecteer een sjabloon de Azure App Service-implementatiesjabloon en selecteer Toepassen. Met deze sjabloon worden automatisch de benodigde taken toegevoegd.

   Notitie

   Als u een Node.js-app implementeert in App Service in Windows, selecteert u de sjabloon Een Node.js-app implementeren in Azure App Service . Met deze sjabloon configureert u de taak voor het genereren van een web.config-bestand met een parameter waarmee de iisnode service wordt gestart.

3. Selecteer op de pagina Nieuwe release-pijplijn het tabblad Taken , selecteer Fase 1 en voltooi de volgende velden onder Parameters:

   • Azure-abonnement: Als u nog geen Azure-serviceverbinding hebt, selecteert u uw Azure-abonnement en selecteert u Autoriseren om de vereiste serviceverbinding te maken.
   • App-type: Selecteer Azure Web App in Linux of Azure Web App in Windows, zodat deze overeenkomt met uw code- en agentspecificatie.
   • App Service-naam: selecteer uw App Service-app.

4. Selecteer Toevoegen op het tabblad Pijplijn van het scherm Nieuwe release-pijplijn naast Artefacten.

5. Controleer in het scherm Een artefact toevoegen of Build is geselecteerd en selecteer onder Bron (build-pijplijn) de pijplijn die u in de vorige sectie hebt gemaakt.

6. Selecteer Toevoegen.

7. Selecteer op de pagina Pijplijn rechtsboven opslaan en selecteer VERVOLGENS OK.

8. Als u de pijplijn wilt uitvoeren, selecteert u op de pagina Pijplijn de optie Release maken en selecteert u Vervolgens Maken.

De Azure-web-app-taak wordt geïmplementeerd in 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 .

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

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

De Azure-web-app-taak wordt geïmplementeerd in de hoofdtoepassing in de Azure-web-app. Als u wilt implementeren naar een specifieke virtuele toepassing, voert u de naam in de eigenschap Virtual Application van de Azure App Service-implementatietaak in.

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

• azureSubscription: uw Azure-serviceverbinding.
• appType: Optioneel app-type, zoals webAppLinux implementeren in een web-app in Linux.
• appName: De naam van uw bestaande app.
• deployToSlotOrASE:Booleaans. Of u nu implementeert in een bestaande implementatiesite of App Service-omgeving.
• resourceGroupName: Naam van de resourcegroep die moet worden geïmplementeerd, vereist als deployToSlotOrASE waar is.
• slotName: Naam van de site die moet worden geïmplementeerd, vereist indien deployToSlotOrASE waar. Standaardwaarde is production.
• package: Bestandspad naar het pakket of de map met de inhoud van uw app. Wildcards worden ondersteund.
• SourceSlot: Slot naar productie verzonden wanneer SwapWithProduction waar is.
• SwapWithProduction:Booleaans. Of het verkeer van de bronsite moet worden gewisseld met productie.

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.

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'

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.

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

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

In het volgende voorbeeld ziet u hoe u stapvoorwaarden gebruikt om alleen geslaagde 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>'

Zie Voorwaarden opgeven voor meer informatie over voorwaarden.

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 de volgende artikelen voor meer informatie:

• Klassieke releasetriggers
• Implementatiebeheer met behulp van goedkeuringen
• Concepten van implementatiepoorten

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'

Als u de Azure App Service-implementatiesjabloon in een release-pijplijn gebruikt, volgt u deze stappen om te implementeren in Web Deploy.

1. Selecteer het tabblad Taken en selecteer Vervolgens Azure App Service implementeren, de Azure App Service-implementatietaak .
2. Controleer in het configuratiescherm of het verbindingstype is ingesteld op Azure Resource Manager.
3. Vouw aanvullende implementatieopties uit en kies Implementatiemethode selecteren. Zorg ervoor dat Web Deploy is geselecteerd als de implementatiemethode.
4. Sla de release-pijplijn op.