Bereitstellen in App Service mithilfe von Azure Pipelines

1. Melden Sie sich bei Ihrer Azure DevOps-Organisation an, und navigieren Sie zu Ihrem Projekt.

2. Wechseln Sie zu Pipelines, und wählen Sie dann Neue Pipeline aus.

3. Wenn Sie dazu aufgefordert werden, wählen Sie den Speicherort Ihres Quellcodes aus: entweder Azure Repos Git oder GitHub.

   Möglicherweise werden Sie zu GitHub weitergeleitet, um sich anzumelden. Geben Sie in diesem Fall Ihre Anmeldeinformationen für GitHub ein.

4. Wenn die Liste der Repositorys angezeigt wird, wählen Sie Ihr Repository aus.

5. Sie werden möglicherweise zu GitHub weitergeleitet, um die Azure Pipelines-App zu installieren. Wählen Sie in diesem Fall Genehmigen & installieren aus.

6. Wählen Sie bei Anzeige der Registerkarte Konfigurieren die Option ASP.NET Core aus.

7. Wenn Ihre neue Pipeline angezeigt wird, sehen Sie sich den YAML-Code an, um herauszufinden, was er macht. Wenn Sie so weit sind, wählen Sie Speichern und ausführen aus.

Erste Schritte:

1. Erstellen Sie eine Pipeline, und wählen Sie die ASP.NET Core-Vorlage aus. Durch diese Auswahl werden automatisch die Aufgaben hinzugefügt, die zum Erstellen des Codes im Beispielrepository erforderlich sind.

2. Speichern Sie die Pipeline, und stellen Sie einen Build in die Warteschlange, um sich die Pipeline in Aktion anzusehen.

   Die ASP.NET Core-Pipelinevorlage veröffentlicht später die ZIP-Bereitstellungsdatei als Azure-Artefakt für die Bereitstellungsaufgabe.

1. Klicken Sie am Ende der YAML-Datei, und wählen Sie dann Assistent anzeigen aus.

2. Verwenden Sie den Aufgaben-Assistenten, um die Azure-Web-App-Aufgabe hinzuzufügen.

   

   Alternativ können Sie die Azure App Service-Bereitstellungsaufgabe (AzureRmWebAppDeployment) hinzufügen.

3. Wählen Sie Ihr Azure-Abonnement aus. Stellen Sie sicher, dass Sie Ihre Verbindung Autorisieren. Die Autorisierung erstellt die erforderliche Dienstverbindung.

4. Wählen Sie App-Typ, App-Nameund Runtimestapel basierend auf Ihrer App Service-App aus. Die vollständige YAML-Datei sollte dem folgenden Code ähneln:

   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: Name der autorisierten Dienstverbindung mit Ihrem Azure-Abonnement
   • appName: Name der vorhandenen App
   • package: Dateipfad zum Paket oder Ordner, das bzw. der die App-Dienstinhalte enthält. Platzhalter werden unterstützt.

Erste Schritte:

1. Erstellen Sie eine Releasepipeline, indem Sie im linken Menü Releases und dann Neue Pipeline auswählen.

2. Wählen Sie die Azure App Service-Bereitstellungsvorlage für Ihre Phase aus. Dadurch werden automatisch die notwendigen Aufgaben hinzugefügt.

   Hinweis

   Wenn Sie eine Node.js-App in App Service unter Windows bereitstellen, wählen Sie die Vorlage Node.js-App in Azure App Service bereitstellen aus. Der einzige Unterschied zwischen diesen Vorlagen besteht darin, dass die Node.js-Vorlage die Aufgabe so konfiguriert, dass sie eine web.config-Datei generiert, die einen Parameter enthält, der den iisnode-Dienst startet.

3. Um diese Releasepipeline mit dem Azure-Artefakt aus dem vorherigen Schritt zu verknüpfen, wählen Sie Artefakt hinzufügen>Build aus.

4. Wählen Sie unter Quelle (Buildpipeline) die Buildpipeline aus, die Sie im vorherigen Abschnitt erstellt haben, und wählen Sie dann Hinzufügen aus.

5. Speichern Sie die Releasepipeline, und erstellen Sie ein Release, um sie in Aktion zu sehen.

Um ein ZIP-Webpaket (z. B. von einer ASP.NET-Web-App) in einer Azure-Web-App bereitzustellen, verwenden Sie den folgenden Codeschnipsel, um den Build in einer App bereitzustellen:

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: Ihr Azure-Abonnement.
• appType: Ihr Web-App-Typ.
• appName: der Name Ihres vorhandenen APP Service.
• package: der Dateipfad zum Paket oder einem Ordner mit Ihrem App-Service-Inhalt. Platzhalter werden unterstützt.

Bei klassischen Pipelines ist es am einfachsten, Build- und Releasephasen auf separaten Seiten zu definieren (Pipelines bzw. Releases). Im Allgemeinen gehen Sie wie folgt vor:

• Erstellen und testen Sie Ihre App auf der Seite Pipelines mithilfe der Vorlage Ihrer Wahl, z. B. ASP.NET Core, Node.js mit Grunt, Maven oder einer anderen Vorlage, und veröffentlichen Sie ein Artefakt.
• Verwenden Sie auf der Seite Release die generische Azure App Service-Bereitstellungsvorlage, um das Artefakt bereitzustellen.

Möglicherweise gibt es Vorlagen für bestimmte Programmiersprachen, aus denen Sie wählen können.

Standardmäßig erfolgt Ihre Bereitstellung in der Stammanwendung in der Azure-Web-App. Sie können mithilfe der Eigenschaft VirtualApplication der Azure App Service-Bereitstellungsaufgabe (AzureRmWebAppDeployment) in einer bestimmten virtuellen Anwendung bereitstellen:

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

• VirtualApplication: Der Name der virtuellen Anwendung, die im Azure-Portal konfiguriert wird. Weitere Informationen finden Sie unter Konfigurieren einer App Service-App im Azure-Portal.

Standardmäßig erfolgt Ihre Bereitstellung in der Stammanwendung in der Azure-Web-App. Wenn Sie die Bereitstellung in einer bestimmten virtuellen Anwendung durchführen möchten, geben Sie deren Namen in die Eigenschaft Virtuelle Anwendung der Azure App Service-Bereitstellungsaufgabe ein.

Das folgende Beispiel zeigt, wie in einem Stagingslot bereitgestellt und dann zu einem Produktionsslot gewechselt wird:

- 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: Ihr Azure-Abonnement.
• appType: (optional) Verwenden Sie webAppLinux zum Bereitstellen in einer Web-App unter Linux.
• appName: der Name Ihres vorhandenen APP Service.
• deployToSlotOrASE: Boolesch. Bereitstellen in einem vorhandenen Bereitstellungsslot oder in einer Azure App Service-Umgebung.
• resourceGroupName: Name der Ressourcengruppe. Erforderlich, wenn deployToSlotOrASE „true“ ist.
• slotName: Name des Slots. Standardeinstellung ist production. Erforderlich, wenn deployToSlotOrASE „true“ ist.
• package: der Dateipfad zum Paket oder einem Ordner mit Ihrem App-Service-Inhalt. Platzhalter werden unterstützt.
• SourceSlot: Slot, der an die Produktion gesendet wird, wenn SwapWithProduction „true“ ist.
• SwapWithProduction: Boolesch. Den Datenverkehr des Quellslots gegen die Produktion tauschen.

Verwenden Sie die Option In Slot oder App Service-Umgebung bereitstellen in der Azure-Web-App-Aufgabe, um den Slot als Bereitstellungsziel anzugeben. Sie können die Slots mithilfe der Aufgabe Azure App Service verwalten tauschen.

Sie können Aufträge in Ihrer YAML-Datei verwenden, um eine Pipeline aus Bereitstellungen einzurichten. Mithilfe von Aufträgen können Sie die Reihenfolge der Bereitstellung in mehreren Web-Apps steuern.

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'

Wenn Sie in mehreren Web-Apps bereitstellen möchten, fügen Sie Ihrer Releasepipeline Stufen hinzu. Sie können die Reihenfolge der Bereitstellung steuern. Weitere Informationen finden Sie unter Stufen.

Der folgende Codeschnipsel zeigt ein Beispiel für die Variablenersetzung mithilfe der Azure App Service-Bereitstellungsaufgabe (AzureRmWebAppDeployment):

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

So ändern Sie connectionString mithilfe der Variablenersetzung:

1. Erstellen Sie eine Releasepipeline mit zwei Stufen.
2. Verknüpfen Sie das Artefakt des Release mit dem Build, der das Webpaket erstellt.
3. Definieren Sie connectionString als Variable in den einzelnen Stufen. Legen Sie den entsprechenden Wert fest.
4. Wählen Sie die Option XML-Variablenersetzung unter Optionen für Dateitransformationen und Variablenersetzungen für die Azure App Service-Bereitstellungsaufgabe aus.

Um dies in YAML zu bewerkstelligen, können Sie eine der folgenden Methoden verwenden:

• Isolieren der Bereitstellungsschritte in einen separaten Auftrag und Hinzufügen einer Bedingung zu diesem Auftrag.
• Hinzufügen einer Bedingung zum Schritt.

Im folgenden Beispiel wird gezeigt, wie Schrittbedingungen verwendet werden, um nur Builds bereitzustellen, die aus dem Mainbranch stammen:

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

Weitere Informationen finden Sie unter Angeben von Bedingungen.

In Ihrer Releasepipeline können Sie verschiedene Überprüfungen und Bedingungen implementieren, um die Bereitstellung zu steuern:

• Legen Sie Branchfilter fest, um den Continuous Deployment-Trigger für das Artefakt der Releasepipeline zu konfigurieren.
• Legen Sie Genehmigungen vor der Bereitstellung als Vorbedingung für die Bereitstellung in einer Stufe fest.
• Konfigurieren Sie Gates als Vorbedingung für die Bereitstellung in einer Stufe.
• Geben Sie Bedingungen für die Ausführung einer Aufgabe an.

Weitere Informationen finden Sie unter Release-, Branch- und Stufen-Trigger, Releasebereitstellungssteuerung mithilfe von Genehmigungen, Releasebereitstellungssteuerung mithilfe von Gates und Angeben von Bedingungen für die Ausführung einer Aufgabe.

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'

In der Releasepipeline, vorausgesetzt, Sie verwenden die Azure App Service-Bereitstellungsvorlage:

1. Wählen Sie die Registerkarte Aufgaben und dann Azure App Service bereitstellen aus. Dies ist die Aufgabe AzureRmWebAppDeployment.

2. Vergewissern Sie sich im Dialogfeld, dass Verbindungstyp auf Azure Resource Manager festgelegt ist.

3. Erweitern Sie im Dialogfeld Zusätzliche Bereitstellungsoptionen, und wählen Sie Bereitstellungsmethode auswählen aus. Stellen Sie sicher, dass Web Deploy als Bereitstellungsmethode ausgewählt ist.

4. Speichern Sie die Releasepipeline.