Test de performance en utilisant des plugins Maven avec JMeter

Lancement d'un test de performance d'une application Web en utilisant des plugins Maven pour Apache JMeter et analyse des résultats du test

Dans cet article, nous allons montrer comment réaliser un test de performance et faire l’analyse des résultats en utilisant la technologie Java Maven à la fois pour lancer le test et aussi pour génèrer des graphes et des tableaux de résultats.

L’application Web testée est une application assez connue nommée JPetstore (dont le projet se trouve à url https://github.com/mybatis/jpetstore-6).

Les avantages de cette solution pour le lancement d’un test et de son analyse

Les détails de l’implémentation et des lancements Maven sont décrits un peu plus bas dans les chapitres de cette page.

Toutefois, on peut commencer en citant les principaux avantages :

• Pour l’installation
  • Il n’y a pas besoin de faire une installation au préalable d’Apache JMeter pour lancer le test de performance car le plugin « jmeter-maven-plugin » va récupérer l’outil Apache JMeter dans le repository Maven Central ainsi que les plugins de JMeter.
  • Les chemins des fichiers sont relatifs au projet Maven et ils peuvent être différents selon les machines utilisées durant la phase de mise au point et aussi en Intégration Continue.
• Pour l’Intégration Continue
  • Cette solution s’intègre facilement dans des pipelines d’Intégration Continue (Jenkins, GitLab …) en lançant les tests dans un noeud Jenkins ou un GitLab Runner et elle est compréhensible par les développeurs et les testeurs.
  • On peut ajouter assez facilement des graphes provenant du monitoring de l’OS et/ou de Java à l’aide d’outil de monitoring comme nmon + nmon visualizer pour les environnements Linux.
• Pour les développeurs et testeurs
  • Les développeurs Java ou testeurs utilisant Maven sont facilement opérationnels et ils sont à l’aise avec ces fichiers pom.xml et Git.
  • Le projet de tests de performance est géré comme un projet Java Maven classique dans l’IDE (IntelliJ, Eclipse, Visual Studio).
  • Les différents fichiers (pom, script JMeter, data csv) sont versionables avec Git ou un autre gestionnaire de source.
  • Le README.md (au format Markdown) du projet peut servir de documentation pour expliquer comment lancer le test de performance et faire l’analyse des résultats notamment en IC.
• Pour l’analyse
  • L’analyse est rapide en quelques minutes les différents fichiers de l’analyse sont créés.
  • On peut filtrer les résultats en ne gardant que les pages et supprimant les urls appelées dans les pages.
  • On peut filtrer les résultats par palier quand il y a plusieurs paliers de montée en charge en lançant plusieurs fois l’outil de filtre du plugin avec les paramètres d’Offset start et end différents.
  • On peut filtrer pour avoir un graphe des temps de réponse par scénario afin d’avoir des graphes plus lisibles contenant un nombre de courbes raisonnable.
  • On peut forcer l’axe des Y pour avoir des graphes plus facilement comparables car ils sont à la même échelle, par exemple Y = 5000 ms pour l’ensemble des Temps de réponse ou bien de 0 à 100% pour la consommation CPU.
  • Les rapports (Aggregate ou Synthesis) sont au format csv et aussi en tableau HTML pour l’affichage dans une page HTML.
  • La page index.html générée permet de visualiser facilement les graphes et les tableaux HTML des rapports.
  • En quelques minutes après le tir de performance, les graphes, les rapports et la page index.html permettent de contrôler les résultats.
  • Dans la page HTML générée, les liens indiquent la taille des fichiers et en cliquant sur le lien, on visualise le contenu comme les logs de JMeter dans un navigateur.
  • S’il manque un graphe ou que l’on désire avoir les temps de chaque url appelée dans une page, on peut le générer manuellement avec l’outil « JMeterPluginsCMD Command Line Tool » et « Filter Results Tool» à partir du fichier des résultats de JMeter ou directement avec les plugins dans JMeter avec l’interface Swing GUI.
• Pour la rédaction d’un rapport
  • Les graphes créés durant l’analyse sont directement récupérables pour les mettre dans un rapport au format Microsoft Word ou Libre Office Writer.
  • Les rapports au format CSV sont éditables dans un tableur (Microsoft Excel ou Libre Office Calc) puis les valeurs formatées sont copiables facilement dans un rapport Word ou Writer.
• Pour l’archivage
  • L’archivage des résultats est assez simple en sauvegardant le répertoire zippé des résultats et de l’analyse.
  • Le format d’archivage permet une comparaison simple entre les différentes campagnes de tests de performance.
  • La durée de conservation des résultats peut être important (plusieurs années) car le format et la lecture des fichiers sont simples, les données ne sont pas stockées en base Documentaire, Relationnelle ou Temporelle.

Lancement d’un test de performance avec Maven et Apache JMeter

Il existe un plugin Maven pour lancer un test de performance avec Apache JMeter. Ce plugin s’appelle : jmeter-maven-plugin (url du projet : https://github.com/jmeter-maven-plugin/jmeter-maven-plugin)

Pour lancer le test de performance avec Java Maven, il faut donc :

• Un JDK/JRE (version 1.8 ou supérieur comme la version 17)
• Maven récent (3.7 ou supérieur)
• Un fichier pom.xml Maven

Il n’y a pas besoin de faire une installation au préalable d’Apache JMeter pour lancer le test de performance.
Il faut généralement un client Git pour récupérer dans le repository, principalement : le script JMeter, les fichiers de configuration externes, les fichiers de données CSV stockés dans un repository Git.
Il est préconisé pour faciliter la maintenance d’avoir 2 fichiers Maven :

• Un premier fichier Maven pom.xml ( pom_01_launch_test.xml ) pour lancer le test de performance
• Un deuxième fichier Maven pom.xml ( pom_02_analyse_results.xml ) pour l’analyse des résultats

L’arborescence du projet préconisé par le plugin jmeter-maven-plugin

Le projet Maven pour lancer un test de performance a des répertoires prédéfinis.

L’arborescence prédéfinie pour le plugin jmeter-maven-plugin est : ${project.base.directory}/src/test/jmeter

Dans ce répertoire, il faut mettre :

• Le script JMeter (.jmx)
• Les fichiers du jeu de données (.csv)
• Les fichiers de configuration externes utilisés dans le script JMeter (.properties)
• Le fichier de configuration de JMeter (user.properties) si certaines properties ne sont pas standards

Le fichier pom.xml de lancement du test de performance

Le 1er fichier pom.xml ( pom_01_launch_test.xml ) contient la déclaration du jmeter-maven-plugin avec quelques properties de configuration.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.soprasteria.vdaburon.jmeter</groupId>
    <artifactId>jpetstore-maven-load-test-dzone</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <name>01 - Launch a load test of the JPetstore web application with the maven plugin</name>
    <description>Launch a load test of the JPetstore web application with the maven plugin</description>
    <inceptionYear>2025</inceptionYear>
    <developers>
        <developer>
            <id>vdaburon</id>
            <name>Vincent DABURON</name>
            <email>vdaburon@gmail.com</email>
            <roles>
                <role>architect</role>
                <role>developer</role>
            </roles>
        </developer>
    </developers>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <jmeter.version>5.6.3</jmeter.version>
        <jvm_xms>256</jvm_xms>
        <jvm_xmx>756</jvm_xmx>

        <prefix_script_name>jpetstore</prefix_script_name>
        <config_properties_name>config_test_warm_up.properties</config_properties_name>
    </properties>

    <build>
        <plugins>
            <plugin>
                <!-- Launch load test with : mvn clean verify -->
                <groupId>com.lazerycode.jmeter</groupId>
                <artifactId>jmeter-maven-plugin</artifactId>
                <version>3.6.1</version>
                <executions>
                    <!-- Generate JMeter configuration -->
                    <execution>
                        <id>configuration</id>
                        <goals>
                            <goal>configure</goal>
                        </goals>
                    </execution>
                    <!-- Run JMeter tests -->
                    <execution>
                        <id>jmeter-tests</id>
                        <goals>
                            <goal>jmeter</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jmeterVersion>${jmeter.version}</jmeterVersion>
                    <jmeterExtensions>
                        <artifact>kg.apc:jmeter-plugins-functions:2.2</artifact>
                        <artifact>kg.apc:jmeter-plugins-dummy:0.4</artifact>
                        <artifact>io.github.vdaburon:pacing-jmeter-plugin:1.0</artifact>
                    </jmeterExtensions>
                    <testPlanLibraries>
                    </testPlanLibraries>
                    <downloadExtensionDependencies>false</downloadExtensionDependencies>
                    <jMeterProcessJVMSettings>
                        <xms>${jvm_xms}</xms>
                        <xmx>${jvm_xmx}</xmx>
                        <arguments>
                            <argument>-Duser.language=en</argument>
                            <argument>-Duser.region=EN</argument>
                        </arguments>
                    </jMeterProcessJVMSettings>
                    <testFilesIncluded>
                        <jMeterTestFile>${prefix_script_name}.jmx</jMeterTestFile>
                    </testFilesIncluded>
                    <propertiesUser>
                        <relatif_data_dir>/</relatif_data_dir>
                        <resultat_dir>${project.build.directory}/jmeter/results/</resultat_dir>
                    </propertiesUser>
                    <customPropertiesFiles>
                        <file>${basedir}/src/test/jmeter/${config_properties_name}</file>
                    </customPropertiesFiles>
                    <logsDirectory>${project.build.directory}/jmeter/results</logsDirectory>
                    <generateReports>false</generateReports>
                    <testResultsTimestamp>false</testResultsTimestamp>
                    <resultsFileFormat>csv</resultsFileFormat>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Lancement d’un tir de performance sur l’application Web JPetstore

Pour le lancement d’un test de performance à 50 pourcent de la charge pour une durée de 10min sur l’application JPestore. On indique :

• Le préfixe du script JMeter avec -Dprefix_script_name=jpetstore (pour le fichier jpetstore.jmx)
• Le nom du fichier de properties avec -Dconfig_properties_name=config_test_50pct_10min.properties (avec la configuration des vusers pour 50% de la charge et la durée de 10 min)

Le fichier de properties (ex: config_test_50pct_10min.properties) contient de la configuration externe qui seront des JMeter properties comme l’url du site à tester, les nombre de vusers par scénario, la durée du test.

Lancement du test de performance par la commande: mvn -Dprefix_script_name=jpetstore -Dconfig_properties_name=config_test_50pct_10min.properties -f pom_01_launch_test.xml clean verify

Notes:

• Il faut que le programme mvn soit dans le PATH ou bien la variable d’environnement MAVEN_HOME soit déclarée.
• Maven utilise un JDK/JRE, il faut donc que dans le fichier de lancement le chemin vers le programme java soit déclaré ou que la variable d’environnement JAVA_HOME soit déclarée.
• Si vous voulez arrêter le test avant la fin prévue, il faut appeler le script shell : <JMETER_HOME>/bin/shutdown.sh (Linux) ou shutdown.cmd (Windows)

Le tir est lancé, les "Summary logs" permettent de suivre l’avancement du tir de performance. On surveille notamment le temps depuis le lancement et le nombre d'erreurs.
Exemple de logs pour le test lancé dans l'IDE IntelliJ:

---

C:\Java\jdk1.8.0_191\bin\java.exe ... -Dmaven.home=C:\software\maven3 -Dprefix_script_name=jpetstore -Dconfig_properties_name=config_test_50pct_10min.properties -f pom_01_launch_test.xml clean verify -f pom_01_launch_test.xml [INFO] Scanning for projects... [INFO] [INFO] --< com.soprasteria.vdaburon.jmeter:jpetstore-maven-load-test-dzone >--- [INFO] Building 01 - Launch a load test of the JPetstore web application with the maven plugin 1.0 [INFO] from pom_01_launch_test.xml
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] --- clean:3.2.0:clean (default-clean) @ jpetstore-maven-load-test-dzone ---
[INFO]
[INFO] --- jmeter:3.6.1:configure (configuration) @ jpetstore-maven-load-test-dzone ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] C O N F I G U R I N G J M E T E R
[INFO] -------------------------------------------------------
[INFO]
[INFO] Creating test configuration for execution ID: configuration
[INFO] Building JMeter directory structure...
[INFO] Generating JSON Test config...
[INFO] Configuring JMeter artifacts...
[INFO] Populating JMeter directory...
[INFO] Copying extensions to C:\demo\jpetstore_loadtesting_dzone\target\1515b131-17ff-4f97-bcb7-ba2eec698862\jmeter\lib\ext
Downloading dependencies: false
[INFO] Copying junit libraries to C:\demo\jpetstore_loadtesting_dzone\target\1515b131-17ff-4f97-bcb7-ba2eec698862\jmeter\lib\junit
Downloading dependencies: true
[INFO] Copying test plan libraries to C:\demo\jpetstore_loadtesting_dzone\target\1515b131-17ff-4f97-bcb7-ba2eec698862\jmeter\lib
Downloading dependencies: true
[INFO] Configuring JMeter properties...
[INFO]
[INFO] --- jmeter:3.6.1:jmeter (jmeter-tests) @ jpetstore-maven-load-test-dzone ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] P E R F O R M A N C E T E S T S
[INFO] -------------------------------------------------------
[INFO]
[INFO] Executing test: jpetstore.jmx
[INFO] Arguments for forked JMeter JVM: [java, -Xms256M, -Xmx756M, -Duser.language=en, -Duser.region=EN, -Djava.awt.headless=true, -jar, ApacheJMeter-5.6.3.jar, -d,
C:\demo\jpetstore_loadtesting_dzone\target\1515b131-17ff-4f97-bcb7-ba2eec698862\jmeter, -j, C:\demo\jpetstore_loadtesting_dzone\target\jmeter\results\jpetstore.jmx.log, -l, C:\demo\jpetstore_loadtesting_dzone\target\jmeter\results\jpetstore.csv,
-n, -q, C:\demo\jpetstore_loadtesting_dzone\src\test\jmeter\config_test_50pct_10min.properties, -t, C:\demo\jpetstore_loadtesting_dzone\target\jmeter\testFiles\jpetstore.jmx, -Dsun.net.http.allowRestrictedHeaders, true]
[INFO]
[INFO] WARN StatusConsoleListener The use of package scanning to locate plugins is deprecated and will be removed in a future release
[INFO] WARN StatusConsoleListener The use of package scanning to locate plugins is deprecated and will be removed in a future release
[INFO] WARN StatusConsoleListener The use of package scanning to locate plugins is deprecated and will be removed in a future release
[INFO] WARN StatusConsoleListener The use of package scanning to locate plugins is deprecated and will be removed in a future release
[INFO] Creating summariser <summary>
[INFO] Created the tree successfully using C:\demo\jpetstore_loadtesting_dzone\target\jmeter\testFiles\jpetstore.jmx
[INFO] Starting standalone test @ September 24, 2025 11:30:22 AM CEST (1758706222410)
[INFO] Waiting for possible Shutdown/StopTestNow/HeapDump/ThreadDump message on port 4445
[INFO] summary + 33 in 00:00:08 = 4.2/s Avg: 100 Min: 30 Max: 1089 Err: 0 (0.00%) Active: 2 Started: 2 Finished: 0
[INFO] summary + 67 in 00:00:29 = 2.3/s Avg: 53 Min: 28 Max: 174 Err: 0 (0.00%) Active: 5 Started: 5 Finished: 0
[INFO] summary = 100 in 00:00:37 = 2.7/s Avg: 69 Min: 28 Max: 1089 Err: 0 (0.00%)
[INFO] summary + 81 in 00:00:30 = 2.7/s Avg: 69 Min: 27 Max: 858 Err: 0 (0.00%) Active: 7 Started: 7 Finished: 0
[INFO] summary = 181 in 00:01:07 = 2.7/s Avg: 69 Min: 27 Max: 1089 Err: 0 (0.00%)
…
[INFO] summary + 47 in 00:00:31 = 1.5/s Avg: 86 Min: 30 Max: 471 Err: 0 (0.00%) Active: 7 Started: 7 Finished: 0 [INFO] summary = 1381 in 00:09:38 = 2.4/s Avg: 71 Min: 27 Max: 1184 Err: 0 (0.00%) [INFO] summary + 36 in 00:00:22 = 1.6/s Avg: 69 Min: 30 Max: 150 Err: 0 (0.00%) Active: 0 Started: 7 Finished: 7 [INFO] summary = 1417 in 00:10:00 = 2.4/s Avg: 71 Min: 27 Max: 1184 Err: 0 (0.00%) [INFO] Tidying up ... @ September 24, 2025 11:40:23 AM CEST (1758706823339) [INFO] ... end of run [INFO] Completed Test: C:\demo\jpetstore_loadtesting_dzone\target\jmeter\testFiles\jpetstore.jmx [INFO] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 10:08 min [INFO] Finished at: 2025-09-24T11:40:24+02:00 [INFO] ------------------------------------------------------------------------ [INFO] Shutdown detected, destroying JMeter process... [INFO] Process finished with exit code 0

---

Les résultats sont dans le répertoire : <PROJECT_HOME>/target/jmeter/results

• jpetstore.jmx.log (JMeter logs)
• error.xml (contient les informations sur les appels en erreur)
• jpetstore.csv (JMeter results)

Analyse des résultats

On utilise le 2ème fichier pom Maven dédié à l’analyse.
Il se nomme : pom_02_analyse_results.xml
Le paramètre de lancement est :

• prefix_script_name, le préfixe du script (sans l'extension), car le fichier des résultats JMeter est <script prefixe>.csv (e.g: jpetstore.csv)

Pour lancer l'analyse, on tape la commande: mvn -Dprefix_script_name=jpetstore -f pom_02_analyse_results.xml verify

Note : PAS de clean car il ne faut pas effacer les résultats du tir de performance.

Le fichier Maven avec le plugin et les outils pour l'analyse

Le plugin Maven et outils sont les suivants :

• jmeter-graph-tool-maven-plugin
• csv-report-to-html
• create-html-for-files-in-directory

Le plugin jmeter-graph-tool-maven-plugin permet de:

• filtrer le fichier de résultats de JMeter pour ne garder que les pages en retirant les URLs des pages, il peut aussi filtrer sur une période du test en gardant que le plateau avec le nombre de vusers stable.
• générer un rapport "Summary" au format CSV
• générer un rapport "Synthesis" au format CSV
• créer des graphes au format PNG (ThreadsStateOverTime, ResponseCodesPerSecond, BytesThroughputOverTime, TransactionsPerSecond, ResponseTimesPercentiles, ResponseTimesOverTime)

L'outil csv-report-to-html lit le fichier CSV d'un rapport (Summary et Synthesis) et génère un tableau HTML avec les données du fichier CSV.
L'outil create-html-for-files-in-directory parcourt le répertoire target/jmeter/results et crée une page index.html permettant de visualiser les différents fichiers images, tableaux HTML et de créer des liens vers les autres fichiers du répertoire.

Le fichier pom_02_analyse_results.xml pour l'analyse

 Le fichier pom_02_analyse_results.xml est le suivant (extrait):

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.soprasteria.vdaburon.jmeter</groupId>
    <artifactId>jpetstore-maven-analyse-result-dzone</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <name>02 - Analyzes the results of the web application JPetstore load test with deditated maven plugins</name>
    <description>Analyzes the results of the web application JPetstore load test with deditated maven plugins</description>
    <inceptionYear>2025</inceptionYear>
    <developers>
        <developer>
            <id>vdaburon</id>
            <name>Vincent DABURON</name>
            <email>vdaburon@gmail.com</email>
            <roles>
                <role>architect</role>
                <role>developer</role>
            </roles>
        </developer>
    </developers>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>

        <jvm_xms>256</jvm_xms>
        <jvm_xmx>756</jvm_xmx>

        <graph_width>960</graph_width>
        <graph_height>800</graph_height>

        <prefix_script_name>jpetstore</prefix_script_name>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.github.vdaburon</groupId>
            <artifactId>csv-report-to-html</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>io.github.vdaburon</groupId>
            <artifactId>create-html-for-files-in-directory</artifactId>
            <version>1.9</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>io.github.vdaburon</groupId>
                <artifactId>jmeter-graph-tool-maven-plugin</artifactId>
                <version>1.2</version>
                <executions>
                    <execution>
                        <id>create-graphs</id>
                        <goals>
                            <goal>create-graph</goal>
                        </goals>
                        <phase>verify</phase>
                        <configuration>
                            <directoryTestFiles>${project.build.directory}/jmeter/testFiles</directoryTestFiles>
                            <filterResultsTool>
                                <filterResultsParam>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}.csv</inputFile>
                                    <outputFile>${project.build.directory}/jmeter/results/${prefix_script_name}_filtred.csv</outputFile>
                                    <successFilter>false</successFilter>
                                    <includeLabels>SC[0-9]+_P.*</includeLabels>
                                    <includeLabelRegex>true</includeLabelRegex>
                                </filterResultsParam>
                            </filterResultsTool>

                            <graphs>
                                <graph>
                                    <pluginType>AggregateReport</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}.csv</inputFile>
                                    <generateCsv>${project.build.directory}/jmeter/results/G01_AggregateReport.csv</generateCsv>
                                    <includeLabels>SC[0-9]+_.*</includeLabels>
                                    <includeLabelRegex>true</includeLabelRegex>
                                </graph>

                                <graph>
                                    <pluginType>SynthesisReport</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}.csv</inputFile>
                                    <generateCsv>${project.build.directory}/jmeter/results/G02_SynthesisReport.csv</generateCsv>
                                    <includeLabels>SC[0-9]+_.*</includeLabels>
                                    <includeLabelRegex>true</includeLabelRegex>
                                </graph>

                                <graph>
                                    <pluginType>ThreadsStateOverTime</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}.csv</inputFile>
                                    <width>${graph_width}</width>
                                    <height>${graph_height}</height>
                                    <generatePng>${project.build.directory}/jmeter/results/G03_ThreadsStateOverTime.png</generatePng>
                                    <relativeTimes>no</relativeTimes>
                                    <paintGradient>no</paintGradient>
                                    <autoScale>no</autoScale>
                                </graph>

                                <graph>
                                    <pluginType>ResponseCodesPerSecond</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}.csv</inputFile>
                                    <width>${graph_width}</width>
                                    <height>${graph_height}</height>
                                    <generatePng>${project.build.directory}/jmeter/results/G05_ResponseCodesPerSecond.png</generatePng>
                                    <relativeTimes>no</relativeTimes>
                                    <paintGradient>no</paintGradient>
                                    <limitRows>100</limitRows>
                                    <autoScale>no</autoScale>
                                    <excludeLabels>SC[0-9]+_.*</excludeLabels>
                                    <excludeLabelRegex>true</excludeLabelRegex>
                                </graph>

                                <graph>
                                    <pluginType>TransactionsPerSecond</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}_filtred.csv</inputFile>
                                    <width>${graph_width}</width>
                                    <height>${graph_height}</height>
                                    <generatePng>${project.build.directory}/jmeter/results/G07_TransactionsPerSecondAggregated.png</generatePng>
                                    <relativeTimes>no</relativeTimes>
                                    <aggregateRows>yes</aggregateRows>
                                    <paintGradient>no</paintGradient>
                                    <limitRows>100</limitRows>
                                    <autoScale>no</autoScale>
                                </graph>

                                <graph>
                                    <pluginType>ResponseTimesPercentiles</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}_filtred.csv</inputFile>
                                    <width>${graph_width}</width>
                                    <height>${graph_height}</height>
                                    <generatePng>${project.build.directory}/jmeter/results/G08_ResponseTimesPercentiles.png</generatePng>
                                    <aggregateRows>no</aggregateRows>
                                    <paintGradient>no</paintGradient>
                                </graph>

                                <graph>
                                    <pluginType>ResponseTimesOverTime</pluginType>
                                    <inputFile>${project.build.directory}/jmeter/results/${prefix_script_name}_filtred.csv</inputFile>
                                    <width>${graph_width}</width>
                                    <height>${graph_height}</height>
                                    <generatePng>${project.build.directory}/jmeter/results/G11_ResponseTimesOverTime_SC01.png</generatePng>
                                    <relativeTimes>no</relativeTimes>
                                    <paintGradient>no</paintGradient>
                                    <limitRows>100</limitRows>
                                    <includeLabels>SC01.*</includeLabels>
                                    <includeLabelRegex>true</includeLabelRegex>
                                    <forceY>2000</forceY>
                                </graph>
                            </graphs>

                            <jMeterProcessJVMSettings>
                                <xms>${jvm_xms}</xms>
                                <xmx>${jvm_xmx}</xmx>
                                <arguments>
                                    <argument>-Duser.language=en</argument>
                                    <argument>-Duser.region=EN</argument>
                                    <argument>-Djmeter.save.saveservice.timestamp_format=yyyy/MM/dd HH:mm:ss.SSS</argument>
                                    <argument>-Djmeter.save.saveservice.default_delimiter=;</argument>
                                </arguments>
                            </jMeterProcessJVMSettings>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <executions>
                    <execution>
                        <id>aggregate_csv_to_html</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>java</goal>
                        </goals>
                        <configuration>
                            <mainClass>io.github.vdaburon.jmeter.utils.ReportCsv2Html</mainClass>
                            <arguments>
                                <argument>${project.build.directory}/jmeter/results/G01_AggregateReport.csv</argument>
                                <argument>${project.build.directory}/jmeter/results/G01_AggregateReportSorted.html</argument>
                                <argument>sort</argument>
                            </arguments>
                        </configuration>
                    </execution>

                    <execution>
                        <id>synthesis_csv_to_html</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>java</goal>
                        </goals>
                        <configuration>
                            <mainClass>io.github.vdaburon.jmeter.utils.ReportCsv2Html</mainClass>
                            <arguments>
                                <argument>${project.build.directory}/jmeter/results/G02_SynthesisReport.csv</argument>
                                <argument>${project.build.directory}/jmeter/results/G02_SynthesisReportSorted.html</argument>
                                <argument>sort</argument>
                            </arguments>
                        </configuration>
                    </execution>

                    <execution>
                        <id>create_html_page_for_files_in_directory</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>java</goal>
                        </goals>
                        <configuration>
                            <mainClass>io.github.vdaburon.jmeter.utils.HtmlGraphVisualizationGenerator</mainClass>
                            <arguments>
                                <argument>${project.build.directory}/jmeter/results</argument>
                                <argument>index.html</argument>
                            </arguments>
                            <systemProperties>
                                <systemProperty>
                                    <key>image_width</key>
                                    <value>${graph_width}</value>
                                </systemProperty>
                                <systemProperty>
                                    <key>add_toc</key>
                                    <value>true</value>
                                </systemProperty>
                            </systemProperties>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

 

Dans le répertoire results, vous trouverez les graphes, les fichiers CSV des rapports, les tableaux HTML pour les rapports, et la page index.html page, qui permet de visualiser les résultats et les liens vers les différents fichiers.
Ce répertoire se trouve dans target/jmeter/results du projet Maven.

La page index.html générée permet de visualiser les graphes et les liens des fichiers dans un navigateur Web.
Extrait de l'affichage de la page HTML générée :


Le fichier de log de JMeter est dans le répertoire :

target/jmeter/results (il ne s'agit pas du répertoire par défaut, le fichier pom.xml pom_01_launch_test.xml a été modifié pour spécifier l'emplacement de fichier de log:
<logsDirectory>${project.build.directory}/jmeter/results</logsDirectory>), le fichier créé est préfixé par le nom du fichier du script + ".log", Ex: jpetstore.jmx.log

Limitations de la solution de tests de performance avec Maven

Ulimits

La limitation ne vient pas directement de Maven mais de la machine (VM ou POD) qui lance le test de performance.
Pour des charges importantes, il faut souvent modifier les paramètres systèmes en augmentant les limites du compte qui fait tourner Apache JMeter.
Sous Linux, les limites sont déclarées dans le fichier /etc/security/limits.conf.
Les valeurs par défaut ne sont pas suffisantes pour un test de performance à forte charge.

Pour les environnements Linux, les limites pour un compte linux sont affichables avec la commande :
ulimit –a

Par défaut, le nombre de fichiers et/ou de connexions réseaux est limité à 1024 maximum.
Par défaut, le nombre de processus est limité à 4096.

Il faut modifier ces limites en éditant en root le fichier /etc/security/limits.conf
Pour le user linux (ici jmeter) qui lance Java, il faut changer les valeurs

jmeter	hard	nproc	16384
jmeter	soft	nproc	16384
jmeter	hard	nofile	16384
jmeter	soft	nofile	16384

Quand le test est lancé par un GitLab Runner (ou un noeud Jenkins), il faut également que le Runner ait des valeurs system adaptées à la charge en CPU, la mémoire disponible et le débit réseau.

Pour aller plus loin

Des étapes supplémentaires

On peut ajouter une étape de compression du fichier csv des résultats de JMeter et XML pour les erreurs car ces fichiers peuvent être très gros et ils se compressent très bien.

Il existe 2 plugins pour valider les résultats par rapport aux KPIs (Key Performance Indicator).

• JUnitReportKpiJMeterReportCsv (https://github.com/vdaburon/JUnitReportKpiJMeterReportCsv)
• JUnitReportKpiCompareJMeterReportCsv (https://github.com/vdaburon/JUnitReportKpiCompareJMeterReportCsv)

On peut ajouter dans l’analyse la génération des résultats des KPIs et faire échouer le pipeline d’Intégration Continue si des KPIs sont en erreurs.

On peut générer un document PDF à partir de la page index.hml avec des outils comme : convert-html-to-pdf (https://github.com/vdaburon/convert-html-to-pdf)
Exemple de document PDF : https://innersource.soprasteria.com/vincent.daburon/blog_load_test_and_analyse_results_with_maven/-/blob/master/doc/images/document.pdf

Monitoring

Il est important de monitorer l’environnent testé durant les tests de performance.
On peut ajouter des étapes supplémentaires pour lancer le monitoring avant le test et arrêter le monitoring après le test de performance et récupérer les fichiers générés durant le monitoring pour lancer l’analyse du monitoring.

Il est recommandé de surveiller l'application et l'environnement avec des outils Application Performance Monitoring (Dynatrace, ELASTIC APM, ...) durant le test de performance.