Cvičení – spouštění zátěžových testů v Azure Pipelines

Dokončeno

V této části spustíte testovací plán, který jste vytvořili v pipeline vydání. Testovací plán používá Apache JMeter ke spouštění zátěžových testů.

Testy spustíte takto:

• Načtěte a prohlédněte si větev Gitu, která implementuje testy.
• Upravte kanál tak, aby nainstaloval JMeter, spustil testovací plán, transformoval výsledky na JUnit a publikoval výsledky do Azure Pipelines.
• Odešlete svou větev na GitHub, pozorujte, jak se testy spouští v Azure Pipelines, a poté prozkoumejte výsledky.

Načtení větve z GitHubu

V této části načtete větev jmeter z GitHubu a přepnete na ni.

Tato větev obsahuje projekt Space Game, se kterým jste pracovali v předchozích modulech. Obsahuje také základní konfiguraci Azure Pipelines.

1. V editoru Visual Studio Code otevřete integrovaný terminál.

2. Pokud chcete stáhnout větev s názvem jmeter z úložiště Microsoftu a přepnout na tuto větev, spusťte následující příkazy git fetch a git checkout:

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

   Pamatujte, že hlavní odkazuje na úložiště Microsoft GitHub. Konfigurace Gitu vašeho projektu rozumí upstreamu vzdáleného úložiště, protože jste tento vztah nastavili, když jste projekt forkovali z úložiště Microsoftu a naklonovali ho místně.

   Za chvíli tuto větev odešlete na úložiště GitHub, známé jako origin.

3. Volitelně můžete v editoru Visual Studio Code otevřít soubor azure-pipelines.yml. Zkontrolujte počáteční konfiguraci.

   Konfigurace se podobá těm, které jste vytvořili v předchozích modulech v tomto studijním programu. Sestaví pouze konfiguraci verze aplikace. Kvůli stručnosti vynechá triggery, ruční schválení a testy, které jste nastavili v předchozích modulech.

   Poznámka

   Robustnější konfigurace může určovat větve, které se účastní procesu sestavení. Pokud chcete například ověřit kvalitu kódu, můžete jednotkové testy spouštět při každém pushnutí změn v libovolné větvi. Aplikaci můžete také nasadit do prostředí, které provádí podrobnější testování. Toto nasazení však provedete pouze v případě, že máte pull request, kandidáta na vydání, nebo když sloučíte kód do main.

   Další informace najdete v tématu Implementace pracovního postupu kódu v kanálu buildu pomocí Gitu a GitHubu a triggerů kanálu buildu a.

4. Na volbu si můžete v editoru Visual Studio Code prohlédnout soubor testovacího plánu JMeter, LoadTest.jmx, a transformaci XLST, JMeter2JUnit.xsl. Soubor XLST transformuje výstup JMeter na JUnit, aby služba Azure Pipelines mohly vizualizovat výsledky.

Přidání proměnných do Azure Pipelines

Původní testovací plán týmu poskytuje pevně zadanou hodnotu názvu hostitele webu Space Game, který běží v přípravném prostředí.

Aby byl testovací plán flexibilnější, vaše verze používá vlastnost JMeter. Vlastnost si můžete představit jako proměnnou, kterou můžete nastavit z příkazového řádku.

Tady je postup, jak je proměnná hostname definována v JMeteru:

Tady je postup, jak proměnná hostname používá funkci __P ke čtení hostname proměnné.

Odpovídající soubor testovacího plánu, LoadTest.jmx, určuje tuto proměnnou a používá ji k nastavení názvu hostitele.

Při spuštění JMeter z příkazového řádku použijete argument -J k nastavení vlastnosti hostname. Tady je příklad:

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

Tady nastavíte proměnnou STAGING_HOSTNAME v Azure Pipelines. Tato proměnná odkazuje na hostname vašeho webu, který je provozován ve službě App Service ve vašem přípravném prostředí. Také nastavujete jmeterVersion, abyste určili verzi JMeter, která se má nainstalovat.

Když agent běží, tyto proměnné se automaticky exportují do agenta jako proměnné prostředí, takže konfigurace potrubí může spustit JMeter tímto způsobem:

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

Před aktualizací konfigurace kanálu teď přidáme proměnné kanálu. Postup:

1. V Azure DevOps přejděte do projektu Space Game – web – nefunkcionální testy.

2. V části Pipelinesvyberte knihovna.

3. Vyberte skupinu proměnných Release.

4. V části Proměnnévyberte + Přidat.

5. Jako název proměnné zadejte STAGING_HOSTNAME. Jako hodnotu zadejte adresu URL instance služby App Service, která odpovídá vašemu přípravnému prostředí, například tailspin-space-game-web-staging-1234.azurewebsites.net.

   Důležitý

   Nezahrnujte do hodnoty předponu protokolu http:// ani https://. JMeter poskytuje protokol při spuštění testů.

6. Přidejte druhou proměnnou s názvem jmeterVersion. Jako hodnotu zadejte 5.4.3.

   Poznámka

   Toto je verze JMeter, kterou jsme naposledy použili k otestování tohoto modulu. Pokud chcete získat nejnovější verzi, viz Stažení Apache JMeter.

7. Pokud chcete uložit proměnnou do pipeliny, vyberte Uložit v horní části stránky.

   Vaše skupina proměnných se podobá té, která je znázorněna na následujícím obrázku:

   

Úprava konfigurace kanálu

V této části upravíte kanál tak, abyste spustili zátěžové testy během testovací fáze.

1. V editoru Visual Studio Code otevřete soubor azure-pipelines.yml. Potom upravte soubor následujícím způsobem:

   Spropitné

   Celý soubor můžete nahradit nebo jenom aktualizovat zvýrazněnou část.

   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
   

   Tady je souhrn změn:

   • Úloha RunLoadTests provádí zátěžové testování pomocí Linux agenta.
   • Úloha RunLoadTests závisí na úloze Deploy, aby se zajistilo, že se úlohy spouštějí ve správném pořadí. Abyste mohli spustit zátěžové testy, musíte web nasadit do služby App Service. Pokud tuto závislost nezadáte, úlohy v rámci fáze se můžou spouštět v libovolném pořadí nebo běžet paralelně.
   • První script úkol stáhne a nainstaluje JMeter. Proměnná kanálu jmeterVersion určuje verzi JMeter, která se má nainstalovat.
   • Druhá script úloha spustí JMeter. Argument -J nastaví vlastnost hostname v JMeter načtením proměnné STAGING_HOSTNAME z kanálu.
   • Třetí script úloha nainstaluje xsltproc, procesor XSLT a transformuje výstup JMeter na JUnit.
   • Úloha PublishTestResults@2 publikuje do pipeline výslednou sestavu JUnit JUnit.xml. Azure Pipelines vám může pomoct vizualizovat výsledky testu.

2. V integrovaném terminálu přidejte do indexu azure-pipelines.yml, potvrďte změny a nasdílejte větev do GitHubu.

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

Sledování spouštění testů ve službě Azure Pipelines

Tady budete sledovat spuštění pipeline. Během fáze staginguvidíte probíhající zátěžové testy.

1. V Azure Pipelines přejděte do sestavení a sledujte jeho průběh během spuštění.

   Během testovací fázevidíte, jak se po nasazení webu spouštějí zátěžové testy.

2. Po dokončení sestavení přejděte na stránku souhrnu.

   

   Uvidíte, že nasazení a zátěžové testy byly úspěšně dokončeny.

3. V horní části stránky si všimněte souhrnu.

   Vidíte, že výsledek sestavení pro web Space Game je stejně jako vždy publikován. Všimněte si také oddílu Testy a pokrytí, který ukazuje, že zátěžové testy prošly.

   

4. Výběrem souhrnu testu zobrazíte celou zprávu.

   Sestava ukazuje, že oba testy prošly.

   

   Pokud by nějaký test selhal, zobrazily by se podrobné výsledky selhání. Z těchto výsledků můžete prozkoumat zdroj selhání.

   Vzpomeňte si, že soubor XSLT vytvoří soubor JUnit s názvem JUnit.xml. Soubor JUnit odpovídá na tyto dvě otázky:

   • Je průměrná doba žádosti kratší než jedna sekunda?
   • Trvá dokončení méně než 10 procent požadavků více než jednu sekundu?

   Zpráva potvrzuje, že tyto požadavky jsou splněny. Pokud chcete zobrazit další podrobnosti, vyberte v sestavě šipku výsledku. Pak se ujistěte, že je vybraná pouze Předaná.

   

   Uvidíte, že Průměrná doba odezvy a Maximální doba odezvy testovací případy byly úspěšné.

   

Poznámka

Používáte plán služby App Service B1, který běží na úrovni Basic. Tento plán je určený pro aplikace s nízkými požadavky na provoz, jako jsou aplikace v testovacím prostředí. Kvůli tomuto plánu může být výkon vašeho webu menší, než očekáváte. V praxi byste zvolili plán pro přípravné prostředí, které lépe odpovídá vašemu produkčnímu prostředí. Například plány Standard a Premium jsou určené pro produkční úlohy. Ty běží na vyhrazených instancích virtuálních počítačů.