Gyakorlat – Terheléses tesztek futtatása az Azure Pipelinesban

Befejeződött

Ebben a szakaszban a kiadási folyamatban létrehozott teszttervet fogja futtatni. A tesztterv Apache JMeter használatával futtat terhelési teszteket.

A tesztek futtatásának menete a következő:

• A teszteket megvalósító Git-ág lekérése és kivétele.
• Módosítsa a folyamatot a JMeter telepítéséhez, a tesztterv futtatásához, az eredmények JUnittá alakításához, és tegye közzé az eredményeket az Azure Pipelinesban.
• Az ág leküldése a GitHubra, a tesztek futtatása az Azure Pipelinesban, majd az eredmények vizsgálata.

Az ág lehívása a GitHubról

Ebben a szakaszban lekéri az ágat a jmeter GitHubról, és kiveheti vagy átválthat erre az ágra.

Ez az ág tartalmazza azt a Space Game-projektet , amellyel a korábbi modulokban dolgozott. Emellett tartalmaz egy Azure Pipelines-konfigurációt is, amellyel kezdeni kell.

1. Nyissa meg az integrált terminált a Visual Studio Code-ban.

2. A Microsoft-adattárból elnevezett jmeter ág letöltéséhez és az ágra való váltáshoz futtassa az alábbi git fetch parancsokat:git checkout

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

   Ne feledje, hogy a felsőbb réteg a Microsoft GitHub-adattárra hivatkozik. A projekt Git-konfigurációja megérti a távoli felsőbb réteget, mert ezt a kapcsolatot akkor állította be, amikor elágaztatott a projektet a Microsoft-adattárból, és helyileg klónozta.

   Ezt az ágat hamarosan leküldi majd a saját, origin nevű GitHub-adattárába.

3. A Visual Studio Code-ban is megnyithatja a azure-pipelines.yml fájlt. Tekintse át a kezdeti konfigurációt.

   A konfiguráció a képzési terv korábbi moduljaiban létrehozottakhoz hasonlít. Csak az alkalmazás kiadási konfigurációját hozza létre. A rövidség kedvéért kihagyja a korábbi modulokban beállított triggereket, manuális jóváhagyásokat és teszteket.

   Feljegyzés

   Egy robusztusabb konfiguráció megadhatja azokat az ágakat, amelyek részt vesznek a buildelési folyamatban. A kódminőség ellenőrzéséhez például minden alkalommal futtathat egységteszteket, amikor bármilyen ágon leküld egy módosítást. Az alkalmazást olyan környezetben is üzembe helyezheti, amely részletesebb tesztelést végez. Ezt az üzembe helyezést azonban csak akkor hajtja végre, ha lekéréses kérelemmel rendelkezik, ha van kiadási jelöltje, vagy amikor kódot egyesít főként.

   További információ: Kód-munkafolyamat implementálása a buildelési folyamatban a Git, a GitHub és a Build folyamat eseményindítóinak használatával.

4. A Visual Studio Code-ban a JMeter teszttervfájl, a LoadTest.jmx és a JMeter2JUnit.xsl XLST-átalakítás is megtalálható. Az XLST-fájl A JMeter-kimenetet JUnit-ra alakítja át, hogy az Azure Pipelines megjeleníthesse az eredményeket.

Változók hozzáadása az Azure Pipelineshoz

A csapat eredeti tesztcsomagja az előkészítési környezetben futó Space Game-webhely gazdagépneve számára tartalmaz egy szigorúan kódolt értéket.

A tesztterv rugalmasabbá tétele érdekében a verzió egy JMeter tulajdonságot használ. Egy tulajdonságot olyan változóként tekinthet, amelyet a parancssorból állíthat be.

A változó definiálása a hostname JMeterben a következőképpen történik:

A változó a hostname __P függvénnyel olvassa be a változóthostname.

A megfelelő loadTest.jmx teszttervfájl megadja ezt a változót, és a gazdagépnév beállításához használja.

Amikor A JMeter parancsot a parancssorból futtatja, az -J argumentummal állíthatja be a tulajdonságot hostname . Példa:

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

Itt állíthatja be a változót az STAGING_HOSTNAME Azure Pipelinesban. Ez a változó a webhely gazdanevére mutat, amely az Előkészítési környezetben futó App Service-en fut. Azt is beállíthatja jmeterVersion , hogy megadja a telepíteni kívánt JMeter-verziót.

Az ügynök futtatásakor a rendszer automatikusan exportálja ezeket a változókat az ügynökbe környezeti változókként, így a folyamatkonfiguráció így futtathatja a JMetert:

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

Most adhatja hozzá a folyamatváltozókat, mielőtt frissítené a folyamatkonfigurációt. Ehhez tegye a következőket:

1. Az Azure DevOpsban nyissa meg a space game - web - Nonfunctional tests projektet.

2. A Folyamatok területen válassza a Kódtár lehetőséget.

3. Válassza ki a Kiadás változócsoportot.

4. A Változók csoportban válassza a + Hozzáadás lehetőséget.

5. A változó nevére írja be a STAGING_HOSTNAME. Az értékéhez adja meg annak az App Service-példánynak az URL-címét, amely megfelel az előkészítési környezetnek, például tailspin-space-game-web-staging-1234.azurewebsites.net.

   Fontos

   Ne foglalja bele az értékbe az előtagot vagy https:// a http:// protokollt. A JMeter biztosítja a protokollt a tesztek futtatásakor.

6. Adjon hozzá egy második, jmeterVersion nevű változót. Az értékéhez adja meg az 5.4.3 értéket.

   Feljegyzés

   Ez a JMeter azon verziója, amelyet legutóbb a modul teszteléséhez használtunk. A legújabb verzió beszerzéséhez tekintse meg az Apache JMeter letöltését.

7. Ha a változót a folyamatba szeretné menteni, válassza a Mentés a lap tetején lehetőséget.

   A változócsoport az alábbi képen láthatóhoz hasonlít:

   

A folyamatkonfiguráció módosítása

Ebben a szakaszban úgy fogja módosítani a folyamatot, hogy az előkészítési szakaszban futtathassa a terhelési teszteket.

1. Nyissa meg a azure-pipelines.yml fájlt a Visual Studio Code-ban. Ezután módosítsa a fájlt az alábbiak szerint:

   Tipp.

   Lecserélheti a teljes fájlt, vagy frissítheti a kiemelt részt.

   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
   

   Íme a módosítások összegzése:

   • A RunLoadTests feladat betölti a tesztelést egy Linux-ügynökből.
   • A RunLoadTests feladat attól függ, hogy a Deploy feladatok a megfelelő sorrendben futnak-e. A terhelési tesztek futtatása előtt telepítenie kell a webhelyet az App Service-ben. Ha nem adja meg ezt a függőséget, a fázison belüli feladatok bármilyen sorrendben futtathatók, vagy párhuzamosan futtathatók.
   • Az első script feladat letölti és telepíti a JMetert. A jmeterVersion folyamatváltozó megadja a telepíteni kívánt JMeter-verziót.
   • A második script feladat JMeter-et futtat. Az -J argumentum a JMeter tulajdonságot úgy hostname állítja be, hogy beolvassa a STAGING_HOSTNAME változót a folyamatból.
   • A harmadik script feladat telepíti az xsltproc-t, egy XSLT-processzort, és JUnit-ra alakítja át a JMeter-kimenetet.
   • A PublishTestResults@2 feladat közzéteszi az eredményül kapott JUnit-jelentést JUnit.xml a folyamaton. Az Azure Pipelines segíthet a teszteredmények vizualizációjában.

2. Az integrált terminálban adjon hozzá azure-pipelines.yml az indexhez, véglegesítse a módosításokat, és küldje el az ágat a GitHubra.

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

A tesztek végigkövetése az Azure Pipelinesban

Itt megtekintheti a folyamat futtatását. Látni fogja, hogy a terhelési tesztek az előkészítés során futnak.

1. Az Azure Pipelinesban nyissa meg a buildet, és kövesse nyomon futás közben.

   Az előkészítés során láthatja, hogy a terhelési tesztek a webhely üzembe helyezése után futnak.

2. A build befejezése után lépjen az összefoglaló oldalra.

   

   Láthatja, hogy az üzembe helyezés és a terhelési tesztek sikeresen befejeződnek.

3. A lap tetejének közelében jegyezze fel az összegzést.

   Láthatja, hogy a Space Game webhely buildösszetevője ugyanúgy jelenik meg, mint mindig. Jegyezze fel a Tesztek és lefedettség szakaszt is, amely azt mutatja, hogy a terhelési tesztek sikeresek.

   

4. A teljes jelentés megtekintéséhez válassza ki a teszt összefoglalását.

   A jelentés azt mutatja, hogy mindkét teszt sikeres volt.

   

   Ha bármelyik teszt sikertelen lenne, a hiba részletes eredményeit láthatja. Ezekből az eredményekből megvizsgálhatja a hiba forrását.

   Ne feledje, hogy az XSLT-fájl létrehoz egy JUnit.xml nevű JUnit-fájlt. A JUnit-fájl a következő két kérdésre válaszol:

   • Az átlagos kérelemidő kevesebb, mint egy másodperc?
   • A kérelmek kevesebb mint 10 százaléka egy másodpercnél több időt vesz igénybe?

   A jelentés bizonyítja, hogy ezek a követelmények teljesülnek. További részletekért kattintson a jelentés Eredmény nyílára. Ezután győződjön meg arról, hogy csak a Pass van kiválasztva.

   

   Láthatja, hogy az átlagos válaszidő és a maximális válaszidő teszt mindkét esetben sikeres volt.

   

Feljegyzés

Az Alapszintű szinten futó B1 App Service-csomagot használja. Ez a csomag olyan alkalmazásokhoz készült, amelyek alacsony forgalmú követelményeket támasztanak, például tesztkörnyezetben lévő alkalmazásokhoz. A terv miatt előfordulhat, hogy a webhely teljesítménye kisebb, mint amire számított. A gyakorlatban az éles környezethez jobban illeszkedő előkészítési környezetet választanánk ki. A Standard és a Premium csomag például éles számítási feladatokhoz készült. Ezek dedikált virtuálisgép-példányokon futnak.