Übung – Ausführen von Auslastungstests in Azure-Pipelines

In diesem Abschnitt führen Sie den Testplan aus, den Sie in der Releasepipeline erstellt haben. Der Testplan verwendet Apache JMeter zum Ausführen von Auslastungstests.

So führen Sie die Tests aus:

Abrufen des Branchs aus GitHub

In diesem Abschnitt fetchen Sie den Branch jmeter aus GitHub und checken ihn aus oder wechseln zu ihm.

Dieser Zweig enthält das Space Game-Projekt , mit dem Sie in früheren Modulen gearbeitet haben. Er enthält auch eine Azure Pipelines-Konfiguration als Ausgangspunkt.

1. Öffnen Sie in Visual Studio Code das integrierte Terminal.

2. Führen Sie die folgenden git fetch- und git checkout-Befehle aus, um einen Branch namens jmeter aus dem Microsoft-Repository herunterzuladen und zu diesem Branch zu wechseln:

   git fetch upstream jmeter
   git checkout -B jmeter upstream/jmeter
   

   Denken Sie daran, dass sich upstream auf das Microsoft GitHub-Repository bezieht. Die Git-Konfiguration Ihres Projekts kann mit dem Upstreamremoterepository arbeiten, weil Sie diese Beziehung eingerichtet haben, als Sie das Projekt aus dem Repository von Microsoft geforkt und es lokal geklont haben.

   Sie pushen diesen Branch an Ihr GitHub-Repository (wird origin bezeichnet).

3. Öffnen Sie optional in Visual Studio Code die azure-pipelines.yml Datei. Überprüfen Sie die anfängliche Konfiguration.

   Die Konfiguration ähnelt denen, die Sie in früheren Modulen in diesem Lernpfad erstellt haben. Es erstellt nur die Releasekonfiguration der Anwendung. Aus Platzgründen werden die Auslöser, manuelle Genehmigungen und Tests, die Sie in vorherigen Modulen eingerichtet haben, weggelassen.

   Hinweis

   Bei einer robusteren Konfiguration könnten die Branches angegeben werden, die am Buildprozess beteiligt sind. Beim Pushen einer Änderung in einem Branch können immer Komponententests ausgeführt werden, um z. B. die Codequalität zu überprüfen. Sie können die Anwendung auch in einer Umgebung bereitstellen, in der umfassendere Tests durchgeführt werden. Diese Bereitstellung erfolgt jedoch nur dann, wenn ein Pull Request vorhanden ist, Sie über einen Release Candidate verfügen oder Code im Branch Main zusammengeführt werden soll.

   Weitere Informationen finden Sie unter Implementieren eines Codeworkflows in Ihrer Buildpipeline mithilfe von Git- und GitHub - und Buildpipelinetriggern.

4. Optional können Sie in Visual Studio Code die JMeter-Testplandatei , LoadTest.jmx und die XLST-Transformation JMeter2JUnit.xsl auschecken. Die XLST-Datei transformiert die JMeter-Ausgabe in JUnit, sodass Azure Pipelines die Ergebnisse visualisieren können.

Hinzufügen von Variablen zu Azure-Pipelines

Der ursprüngliche Testplan des Teams bietet einen fest einprogrammierten Wert für den Hostnamen der Space Game-Website, die in der Staging Umgebung ausgeführt wird.

Um den Testplan flexibler zu gestalten, verwendet Ihre Version eine JMeter-Eigenschaft. Stellen Sie sich eine Eigenschaft als Variable vor, die Sie über die Befehlszeile festlegen können.

So wird die hostname Variable in JMeter definiert:

Hier erfahren Sie, wie die hostname Variable die __P-Funktion verwendet, um die hostname Variable zu lesen.

Die entsprechende Testplandatei LoadTest.jmx gibt diese Variable an und verwendet sie zum Festlegen des Hostnamens.

Wenn Sie JMeter über die Befehlszeile ausführen, verwenden Sie das -J Argument, um die hostname Eigenschaft festzulegen. Ein Beispiel:

apache-jmeter-5.4.3/bin/./jmeter -n -t LoadTest.jmx -o Results.xml -Jhostname=tailspin-space-game-web-staging-1234.azurewebsites.net

Hier legen Sie die STAGING_HOSTNAME Variable in Azure Pipelines fest. Diese Variable verweist auf den Hostnamen Ihrer Website, die in App Service in der Stagingumgebung ausgeführt wird. Zudem legen Sie mit jmeterVersion die zu installierende JMeter-Version fest.

Wenn der Agent ausgeführt wird, werden diese Variablen automatisch als Umgebungsvariablen in den Agent exportiert, sodass Ihre Pipelinekonfiguration JMeter auf diese Weise ausführen kann:

apache-jmeter-5.4.3/bin/./jmeter -n -t LoadTest.jmx -o Results.xml -Jhostname=$(STAGING_HOSTNAME)

Fügen wir nun die Pipelinevariablen hinzu, bevor Sie die Pipelinekonfiguration aktualisieren. Gehen Sie folgendermaßen vor:

1. Wechseln Sie in Azure DevOps zu Ihrem Space Game - Web - Nonfunctional Tests-Projekt .

2. Wählen Sie unter "Pipelines" die Option "Bibliothek" aus.

3. Wählen Sie die Variablengruppe Release aus.

4. Wählen Sie unter "Variablen" +Hinzufügen aus.

5. Geben Sie für den Namen der Variablen STAGING_HOSTNAME ein. Geben Sie für den Wert die URL der App Service-Instanz ein, die Ihrer Stagingumgebung entspricht, z. B. tailspin-space-game-web-staging-1234.azurewebsites.net.

   Von Bedeutung

   Fügen Sie nicht das Protokollpräfix http:// oder https:// in Ihren Wert ein. JMeter stellt das Protokoll bereit, wenn die Tests ausgeführt werden.

6. Fügen Sie eine zweite Variable mit dem Namen jmeterVersion hinzu. Geben Sie den Wert 5.4.3 an.

   Hinweis

   Dies ist die Version von JMeter, die wir zuletzt zum Testen dieses Moduls verwendet haben. Informationen zum Abrufen der neuesten Version finden Sie unter Apache JMeter herunterladen.

7. Um Die Variable in der Pipeline zu speichern, wählen Sie "Speichern " am oberen Rand der Seite aus.

   Ihre Variablengruppe ähnelt der in der folgenden Abbildung gezeigten Gruppe:

   

Ändern der Pipelinekonfiguration

In diesem Abschnitt ändern Sie die Pipeline so, dass ihre Auslastungstests während der Stagingphase ausgeführt werden.

1. Öffnen Sie in Visual Studio Code die azure-pipelines.yml Datei. Ändern Sie dann die Datei wie folgt:

   Tipp

   Sie können die gesamte Datei ersetzen oder einfach den hervorgehobenen Teil aktualisieren.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: '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
     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: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Test'
     displayName: 'Deploy to the test environment'
     dependsOn: Dev
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: test
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameTest)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Test
     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: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameStaging)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
     - job: RunLoadTests
       dependsOn: Deploy
       displayName: 'Run load tests'
       pool:
         vmImage: 'ubuntu-20.04'
       variables:
       - group: Release
       steps:
       - script: |
           wget -c archive.apache.org/dist/jmeter/binaries/apache-jmeter-$(jmeterVersion).tgz
           tar -xzf apache-jmeter-$(jmeterVersion).tgz
         displayName: 'Install Apache JMeter'
       - script: apache-jmeter-$(jmeterVersion)/bin/./jmeter -n -t LoadTest.jmx -o Results.xml -Jhostname=$(STAGING_HOSTNAME)
         displayName: 'Run Load tests'
       - script: |
           sudo apt-get update
           sudo apt-get install xsltproc
           xsltproc JMeter2JUnit.xsl Results.xml > JUnit.xml
         displayName: 'Transform JMeter output to JUnit'
       - task: PublishTestResults@2
         inputs:
           testResultsFormat: JUnit
           testResultsFiles: JUnit.xml
   

   Hier ist eine Zusammenfassung der Änderungen:

   • Der RunLoadTests Job führt Ladetests von einem Linux-Agenten durch.
   • Der RunLoadTests-Job hängt vom Deploy-Job ab, um sicherzustellen, dass die Jobs in der richtigen Reihenfolge ausgeführt werden. Sie müssen die Website in App Service bereitstellen, bevor Sie die Auslastungstests ausführen können. Wenn Sie diese Abhängigkeit nicht angeben, können Aufträge innerhalb der Phase in beliebiger Reihenfolge oder parallel ausgeführt werden.
   • Die erste script Aufgabe lädt JMeter herunter und installiert es. Die jmeterVersion Pipelinevariable gibt die zu installierende Version von JMeter an.
   • Der zweite script-Task führt JMeter aus. Das -J Argument legt die hostname Eigenschaft in JMeter fest, indem die STAGING_HOSTNAME Variable aus der Pipeline gelesen wird.
   • Die dritte script Aufgabe installiert xsltproc, einen XSLT-Prozessor und transformiert die JMeter-Ausgabe in JUnit.
   • Die PublishTestResults@2 Aufgabe veröffentlicht den resultierenden JUnit-Bericht JUnit.xml in der Pipeline. Azure-Pipelines können Ihnen helfen, die Testergebnisse zu visualisieren.

2. Fügen Sie im integrierten Terminal azure-pipelines.yml zum Index hinzu, übernehmen Sie die Änderungen, und übertragen Sie die Verzweigung auf GitHub.

   git add azure-pipelines.yml
   git commit -m "Run load tests with Apache JMeter"
   git push origin jmeter
   

Beobachten der Testausführung in Azure Pipelines

Hier beobachten Sie, wie die Pipeline ausgeführt wird. Die Auslastungstests werden während der Stagingphase ausgeführt.

1. Wechseln Sie in Azure Pipelines zum Build, und verfolgen Sie dessen Ausführung.

   Während des Stagings sehen Sie die Ladetests, die nach der Bereitstellung der Website ausgeführt werden.

2. Wechseln Sie nach Fertigstellung des Builds zur Zusammenfassungsseite.

   

   Sie sehen, dass die Bereitstellung und die Auslastungstests erfolgreich abgeschlossen wurden.

3. Beachten Sie die Zusammenfassung im oberen Bereich der Seite.

   Sie sehen, dass das Buildartefakt für die Website von Space Game wie üblich veröffentlicht wurde. Beachten Sie auch den Abschnitt "Tests und Abdeckung ", der zeigt, dass die Auslastungstests bestanden wurden.

   

4. Wählen Sie die Testzusammenfassung aus, um den vollständigen Bericht anzuzeigen.

   Der Bericht zeigt, dass beide Tests bestanden haben.

   

   Wenn ein Test fehlschlug, würden Sie detaillierte Ergebnisse des Fehlers sehen. Aus diesen Ergebnissen können Sie die Quelle des Fehlers untersuchen.

   Erinnern Sie sich daran, dass die XSLT-Datei eine JUnit-Datei mit dem Namen JUnit.xmlerzeugt. Die JUnit-Datei beantwortet diese beiden Fragen:

   • Ist die durchschnittliche Anforderungszeit weniger als eine Sekunde?
   • Benötigen Sie weniger als 10 Prozent der Anforderungen mehr als eine Sekunde, um sie abzuschließen?

   Der Bericht beweist, dass diese Anforderungen erfüllt sind. Um weitere Details anzuzeigen, wählen Sie den Ergebnispfeil im Bericht aus. Stellen Sie dann sicher, dass nur Erfolgreich ausgewählt ist.

   

   Sie sehen, dass die Testfälle " Durchschnittliche Reaktionszeit" und " Max Response Time " beide erfolgreich waren.