Tutorial: Erstellen einer mehrstufigen Pipeline mit Azure DevOps

Azure DevOps Services | Azure DevOps Server 2022 | Azure DevOps Server 2019

Sie können eine mehrstufige Azure DevOps-Pipeline verwenden, um Ihren CI/CD-Prozess in Phasen zu unterteilen, die verschiedene Teile Ihres Entwicklungszyklus verkörpern. Die Verwendung einer mehrstufigen Pipeline bietet Ihnen mehr Einblick in Ihren Bereitstellungsprozess und erleichtert die Integration von Genehmigungen und Überprüfungen.

In diesem Artikel erstellen Sie zwei App Service-Instanzen sowie eine YAML-Pipeline mit drei Phasen:

• Build: Erstellen des Quellcodes und eines Pakets
• Entwicklung: Bereitstellen Ihres Paket zu Testzwecken auf einer Entwicklungswebsite
• Staging: Bereitstellen in einer Azure App Service-Staginginstanz mit manueller Genehmigungsprüfung

In einem realen Szenario haben Sie je nach DevOps-Prozess möglicherweise eine weitere Phase für die Bereitstellung in der Produktion.

Der Beispielcode in dieser Übung bezieht sich auf eine .NET-Webanwendung für ein Weltraumspiel, das eine Bestenliste mit den erreichten Highscores beinhaltet. Sie nehmen die Bereitstellung sowohl in der Entwicklungs- als auch in der Staginginstanz von Azure-Web-App für Linux vor.

Voraussetzungen

• Ein GitHub-Konto, in dem Sie ein Repository erstellen können. Erstellen Sie ein kostenloses Konto.
• Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
• Eine Azure DevOps-Organisation und ein entsprechendes Projekt. Erstellen Sie ein kostenloses Konto.
• Möglichkeit zum Ausführen von Pipelines auf von Microsoft gehosteten Agents. Sie können entweder einen Parallelauftrag erwerben oder einen Free-Tarif anfordern.

Forken des Projekts

Forken Sie das folgende Beispielrepository auf GitHub.

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy

Erstellen der App Service-Instanzen

Bevor Sie Ihre Pipeline bereitstellen können, müssen Sie zunächst eine App Service-Instanz für die Bereitstellung erstellen. Sie verwenden Azure CLI, um die Instanz zu erstellen.

1. Melden Sie sich beim Azure-Portal an.

2. Wählen Sie im Menü Cloud Shell und die Bash-Oberfläche aus.

3. Generieren Sie eine Zufallszahl, damit der Domänennamen der Web-App eindeutig ist. Der Vorteil eines eindeutigen Werts besteht darin, dass Ihre App Service-Instanz keinen Namenskonflikt mit den Namen anderer Lernender, die dieses Tutorial absolvieren, erzeugen kann.

   webappsuffix=$RANDOM    
   

4. Öffnen Sie eine Eingabeaufforderung und verwenden Sie einen „az group create“-Befehl, um eine Ressourcengruppe namens tailspin-space-game-rg zu erstellen, die alle Ihre App Service-Instanzen enthält. Aktualisieren Sie den Wert „location“, um Ihre nächstgelegene Region zu verwenden.

   az group create --location eastus --name tailspin-space-game-rg
   

5. Verwenden Sie die Eingabeaufforderung, um einen App Service-Plan zu erstellen.

   az appservice plan create \
     --name tailspin-space-game-asp \
     --resource-group tailspin-space-game-rg \
     --sku B1 \
     --is-linux
   

6. Erstellen Sie in der Eingabeaufforderung mit dem Befehl „az webapp create“ zwei App Service-Instanzen, eine für jede Instanz (Entwicklung und Staging).

   az webapp create \
     --name tailspin-space-game-web-dev-$webappsuffix \
     --resource-group tailspin-space-game-rg \
     --plan tailspin-space-game-asp \
     --runtime "DOTNET|6.0"
   
   az webapp create \
     --name tailspin-space-game-web-staging-$webappsuffix \
     --resource-group tailspin-space-game-rg \
     --plan tailspin-space-game-asp \
     --runtime "DOTNET|6.0"
   

7. Listen Sie in der Eingabeaufforderung mit dem Befehl „az webapp list“ beide App Service-Instanzen auf, um zu überprüfen, ob sie ausgeführt werden.

   az webapp list \
     --resource-group tailspin-space-game-rg \
     --query "[].{hostName: defaultHostName, state: state}" \
     --output table
   

8. Kopieren Sie die Namen der App Service-Instanzen, die im nächsten Abschnitt als Variablen verwendet werden.

Erstellen Ihres Azure DevOps-Projekts und der Variablen

Richten Sie Ihr Azure DevOps-Projekt und eine Buildpipeline ein. Fügen Sie außerdem Variablen für Ihre Entwicklungs- und Staging-Instanz hinzu.

Ihre Buildpipeline:

• Enthält einen Trigger, der ausgeführt wird, wenn eine Codeänderung in der Verzweigung erfolgt.
• Definiert zwei Variablen: „buildConfiguration“ und „releaseBranchName“.
• Enthält eine Phase mit dem Namen „Build“, die die Webanwendung erstellt.
• Veröffentlicht ein Artefakt, das Sie in einer späteren Phase verwenden werden.

Hinzufügen der Build-Phase

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

2. Gehen Sie zu Pipelines und wählen Sie dann Neue Pipeline aus oder Pipeline erstellen, wenn Sie Ihre erste Pipeline erstellen.

3. Führen Sie die Schritte des Assistenten aus. Dabei wählen Sie zuerst GitHub als Speicherort Ihres Quellcodes aus.

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

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

6. Sie werden möglicherweise zu GitHub weitergeleitet, um die Azure Pipelines-App zu installieren. Wählen Sie in diesem Fall „Approve & Install“ (Genehmigen und installieren) aus.

7. Wenn die Registerkarte Konfigurieren angezeigt wird, wählen Sie Starterpipeline aus.

8. Ersetzen Sie den Inhalt von azure-pipelines.yml durch diesen Code.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   

9. Wenn Sie so weit sind, wählen Sie Speichern und ausführen aus.

Hinzufügen der Instanzvariablen

1. Navigieren Sie in Azure DevOps zu Pipelines>Bibliothek.

2. Wählen Sie + Variable group (Variablengruppe) aus.

3. Fügen Sie unter Eigenschaften als Variablengruppennamen Release hinzu.

4. Erstellen Sie zwei Variablen, um auf Ihre Entwicklungs- und Staging-Hostnamen zu verweisen. Ersetzen Sie den Wert „1234“ jeweils durch den korrekten Wert für Ihre Instanz.

   Variablenname	Beispielwert
   WebAppNameDev	tailspin-space-game-web-dev-1234
   WebAppNameStaging	tailspin-space-game-web-staging-1234

5. Wählen Sie Speichern aus, um Ihre Änderungen zu speichern.

Hinzufügen der Dev-Phase

Als Nächstes aktualisieren Sie Ihre Pipeline, um Ihren Build in die Entwicklungsphase zu verschieben.

1. Navigieren Sie in Azure Pipelines zu Pipelines>Pipelines.

2. Wählen Sie im Kontextmenü Bearbeiten aus, um Ihre Pipeline zu bearbeiten.

   

3. Aktualisieren Sie azure-pipelines.yml, um eine Dev-Phase einzuschließen. In der Entwicklungsphase wird Ihre Pipeline:

   • Ausführen, wenn die Buildphase aufgrund einer Bedingung erfolgreich ist.

   • Ein Artefakt von „drop“ herunterladen.

   • Mit einer Azure Resource Manager-Dienstverbindung in Azure App Service bereitstellen.

     trigger:
     - '*'
     
     variables:
       buildConfiguration: 'Release'
       releaseBranchName: 'release'
     
     stages:
     - stage: 'Build'
       displayName: 'Build the web application'
       jobs: 
       - job: 'Build'
         displayName: 'Build job'
         pool:
           vmImage: 'ubuntu-20.04'
           demands:
           - npm
     
         variables:
           wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
           dotnetSdkVersion: '6.x'
     
         steps:
         - task: UseDotNet@2
           displayName: 'Use .NET SDK $(dotnetSdkVersion)'
           inputs:
             version: '$(dotnetSdkVersion)'
     
         - task: Npm@1
           displayName: 'Run npm install'
           inputs:
             verbose: false
     
         - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
           displayName: 'Compile Sass assets'
     
         - task: gulp@1
           displayName: 'Run gulp tasks'
     
         - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
           displayName: 'Write build info'
           workingDirectory: $(wwwrootDir)
     
         - task: DotNetCoreCLI@2
           displayName: 'Restore project dependencies'
           inputs:
             command: 'restore'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Build the project - $(buildConfiguration)'
           inputs:
             command: 'build'
             arguments: '--no-restore --configuration $(buildConfiguration)'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Publish the project - $(buildConfiguration)'
           inputs:
             command: 'publish'
             projects: '**/*.csproj'
             publishWebProjects: false
             arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
             zipAfterPublish: true
     
         - publish: '$(Build.ArtifactStagingDirectory)'
           artifact: drop
     
     - stage: 'Dev'
       displayName: 'Deploy to the dev environment'
       dependsOn: Build
       condition:  succeeded()
       jobs:
       - deployment: Deploy
         pool:
           vmImage: 'ubuntu-20.04'
         environment: dev
         variables:
         - group: Release
         strategy:
           runOnce:
             deploy:
               steps:
               - download: current
                 artifact: drop
               - task: AzureWebApp@1
                 displayName: 'Azure App Service Deploy: website'
                 inputs:
                   azureSubscription: 'your-subscription'
                   appType: 'webAppLinux'
                   appName: '$(WebAppNameDev)'
                   package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
     

4. Ändern Sie die Aufgabe „AzureWebApp@1“, um Ihr Abonnement zu verwenden.

   1. Wählen Sie für die Aufgabe Einstellungen aus.

      

   2. Aktualisieren Sie den Wert „your-subscription“ für das Azure-Abonnement, um Ihr eigenes Abonnement zu verwenden. Möglicherweise müssen Sie den Zugriff im Rahmen dieses Prozesses autorisieren. Wenn beim Autorisieren Ihrer Ressource im YAML-Editor ein Problem auftritt, besteht ein alternativer Ansatz darin, eine Dienstverbindung zu erstellen.

      

   3. Legen Sie unter Linux den App-Typ auf „Web-App“ fest.

   4. Wählen Sie Hinzufügen aus, um die Aufgabe zu aktualisieren.

5. Speichern Sie Ihre Pipeline und führen Sie sie aus.

Hinzufügen der Staging-Phase

Im letzten Schritt stufen Sie die Entwicklungsphase auf „Staging“ hoch. Im Gegensatz zur Entwicklungsumgebung möchten Sie über die Stagingumgebung mehr Kontrolle haben. Daher fügen Sie eine manuelle Genehmigung hinzu.

Erstellen einer Stagingumgebung

1. Klicken Sie in Azure Pipelines auf Umgebungen.

2. Wählen Sie Neue Umgebung aus.

3. Erstellen Sie eine neue Umgebung namens staging und legen Sie die Ressource auf Keine fest.

4. Wählen Sie auf der Seite der Stagingumgebung Genehmigungen und Überprüfungen aus.

   

5. Wählen Sie Genehmigungen aus.

6. Wählen Sie unter Genehmigende Personen die Option Benutzer und Gruppen hinzufügen und dann Ihr Konto aus.

7. Geben Sie unter Anweisungen für genehmigende Personen den Text Diese Änderung genehmigen, wenn sie für das Staging bereit ist.

8. Wählen Sie Speichern aus.

Hinzufügen einer neuen Phase zur Pipeline

Sie fügen der Pipeline nun die neue Phase „Staging“ hinzu, die eine manuelle Genehmigung umfasst.

1. Bearbeiten Sie Ihre Pipelinedatei, und fügen Sie den Abschnitt „Staging“ hinzu.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   
   - stage: 'Dev'
     displayName: 'Deploy to the dev environment'
     dependsOn: Build
     condition:  succeeded()
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: dev
       variables:
       - group: Release
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Dev
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: staging
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   

2. Ändern Sie die Aufgabe „AzureWebApp@1“ in der Stagingphase, um Ihr Abonnement zu verwenden.

   1. Wählen Sie für die Aufgabe Einstellungen aus.

      

   2. Aktualisieren Sie den Wert „your-subscription“ für das Azure-Abonnement, um Ihr eigenes Abonnement zu verwenden. Möglicherweise müssen Sie den Zugriff im Rahmen dieses Prozesses autorisieren.

      

   3. Legen Sie unter Linux den App-Typ auf „Web-App“ fest.

   4. Wählen Sie Hinzufügen aus, um die Aufgabe zu aktualisieren.

3. Wechseln Sie zur Pipelineausführung. Sehen Sie sich die Ausführung des Builds an. Wenn sie „Staging“ erreicht, wartet die Pipeline auf die manuelle Genehmigung des Releases. Sie erhalten außerdem eine E-Mail, die besagt, dass in Ihrer Pipeline eine Genehmigung aussteht.

   

4. Überprüfen Sie die Genehmigung, und lassen Sie die Ausführung der Pipeline zu.

   

Bereinigen von Ressourcen

Wenn Sie diese Anwendung nicht weiter verwenden möchten, löschen Sie die Ressourcengruppe im Azure-Portal und das Projekt in Azure DevOps mithilfe folgender Schritte:

So bereinigen Sie Ihre Ressourcengruppe

1. Wechseln Sie zum Azure-Portal, und melden Sie sich an.

2. Wählen Sie in der Menüleiste „Cloud Shell“ aus. Wenn Sie dazu aufgefordert werden, wählen Sie die Bash-Benutzeroberfläche aus.

   

3. Führen Sie den folgenden az group delete-Befehl aus, um die von Ihnen verwendete Ressourcengruppe tailspin-space-game-rg zu löschen.

   az group delete --name tailspin-space-game-rg
   

So löschen Sie Ihr Azure DevOps-Projekt, einschließlich der Buildpipeline:

1. Navigieren Sie in Azure DevOps zu Ihrem Projekt.

2. Wählen Sie Projekteinstellungen aus.

3. Wählen Sie in den ProjektdetailsLöschen aus.

Verwandter Inhalt

• Wichtige Konzepte für neue Azure Pipelines-Benutzer*innen
• Bereitstellen in App Service mithilfe von Azure Pipelines