19 décembre 2013

Gatling - Tests de très fortes montées en charge

Gatling permet de faire des tests de performance et de montée en charge sur des serveurs.

Plus performant que JMeter, il permet de simuler une montée en charge plus importante avec encore plus d'utilisateurs.

Il est possible de lancer Gatling depuis eclipse, en ligne de commandes, depuis Maven et même depuis Jenkins, ce qui permet d'inclure les tests de performance dans le processus d'intégration continue.

Les sénarios de Gatling sont écrits en Scala dans une syntaxe suffisamment simple pour ne pas nécessiter un apprentissage de ce langage.

Cet article présente comment créer un projet pour Gatling et lancer un test de montée en charge.

Sommaire

Nous verrons une présentation de Gatling avec un rapide comparatif entre JMeter et Gatling.

Nous allons ensuite :
  • créer un projet Gatling dans notre IDE
  • enregistrer un scénairo à l'aide de notre navigateur
  • lancer le scénario depuis l'IDE
  • adapter le scénario pour tester une montée en charge
  • lancer le scénario depuis le programme Gatling.


Présentation

Gatling permet comme JMeter de tester les performances en simulant une montée en charge du serveur.

L'intérêt de Gatling est d'être plus performant que JMeter pour tester une très forte montée en charge avec plusieurs milliers d'utilisateurs. L'autre intérêt est de pouvoir écrire des scénarios plus complexes qu'avec JMeter.

Gatling ne propose pas d'éditeur: nous utilisons notre IDE comme eclipse ou intellijidea pour créer un projet Maven à partir d'un archetype dans lequel nous allons écrire nos scénarios. Ces scénarios sont écrits en Scala. La syntaxe se veut simple pour qu'un utilisateur ne connaissant pas Scala puisse en écrire et les modifier. En tout cas l'IDE permettra l'auto-complétion et indiquera les erreurs de compilations. Nous ne serons pas perdus !

Comme sur JMeter, Gatling fournit un enregistreur des requêtes effectuées par le navigateur Web pour enregistrer un scénario. Ceci permet d'avoir notre modèle du scénario et de n'avoir plus qu'à l'adapter pour simuler la montée en charge en indiquant différents paramètres comme le nombre d'utilisateurs et letype de montée en charge.

Nous avons plusieurs moyens pour lancer nos scénarios de test :
  • soit depuis notre projet sur notre IDE
  • soit depuis le programme Gatling en ligne de commandes sans interface graphique
  • soit via Maven, via le plugin gatling-maven-plugin
  • soit depuis Jenkins, via le plugin Gatling+Plugin
Gatling va générer un rapport en HTML qui a une présentation plus sympathique que sur JMeter, dont voici un exemple :

Créer le projet pour Gatling

Nous allons maintenant créer le projet Maven / Scala pour Gatling:
  • soit avec eclipse
  • soit avec IntellijIDEA (version gratuite)

IntellijIDEA

Pour en faciliter leur développement, nous utilisons IntellijIDEA disponible en version gratuite communautaire :
  • Cliquer sur Configure > Plugins > Browse repositories
  • Rechercher Scala et double cliquer sur Scala pour lancer son installation
  • Patienter jusqu'à la fin de l'installation de ce plugin
  • Une fois le plugin Scala installé, fermer la fenêtre
  • IntellijIDEA va demander à redémarrer
  • L'écran d'accueil d'IntellijIDEA apparaît de nouveau

Créer le projet

  • Cliquer sur Create New Project > Maven
  • Indiquer dans Project SDK > New la localisation du répertoire d'installation du JDK
  • Définir le nom du projet gantling
  • Définir le répertoire du projet gantling
  • Cliquer sur Next
  • Cocher la case Create from archetype puis cliquer sur Add archetype
  • La fenêtre Add archetype apparaît : l'agrandir pour voir tous les champs de saisie
  • Saisir les champs suivants :
    • pour la version 1.5.3 :
      • GroupId : com.excilys.ebi.gatling.highcharts
      • ArtifactId : gatling-highcharts-maven-archetype
      • Version : 1.5.3
    • pour la version 2.0.0-M3a :
      • GroupId : io.gatling.highcharts
      • ArtifactId : gatling-highcharts-maven-archetype
      • Version : 2.0.0-M3a
    • Repository : http://repository.excilys.com/content/groups/public
  • Cliquer sur Next puis sur Finish
IntellijIDEA va maintenant créer le projet depuis l'archetype de Gatling.
La console Maven doit indiquer un message de succès de création du projet.
  • Vérifier que les dépendances Maven sont bien téléchargées
  • Vérifier qu'aucune erreur n'est présente dans ce projet

Lancer l'enregistreur de scénario

Nous pouvons lancer la fenêtre d'enregistrement de Gatling :
  • Cliquer sur Build > Make module gantling pour compiler le projet
  • Dans le répertoire src/test/scala, clic droit sur Recorder, puis Run 'Recorder'
  • La fenêtre Gantling Recorder doit apparaître
  • Passer à l'étape "Enregistrement du scénario" de cet article

Eclipse

Sur Eclipse, nous avons besoin des éléments suivants :
Dans Eclipse, nous ajoutons l'URL du repository des archetypes Maven de Gatling:
  • Menu : Window > Preferences > Maven > Archetypes
  • Cliquer sur Add Remote Catalog
  • Fenêtre Remote Archetype Catalog
  • Fermer la fenêtre des préférences

Créer le projet

  • Dans eclipse, créer un projet de type Maven
  • Sélectionner l'archetype gatling-highcharts-maven-archetype correspondant à la version souhaitée, soit 1.5.3, soit 2.0.0
  • Saisir les informations du projet pour Maven : groupId, artifactId, version, package de base
  • Valider la création du projet
  • Vérifier que Maven récupère bien toutes les dépendances
    • Si ce n'est pas le cas, faire clic droit sur le projet puis : 
      • Maven > Update project > Force Update of Snapshots/Releases > OK

Lancer l'enregistreur de scénario

Nous lançons la fenêtre d'enregistrement des requêtes de Gatling:
  • Dans le répertoire src/test/scala, faire clic droit sur l'objet Recorder puis Run as > Scala application
  • La fenêtre d'enregistrement des requêtes de Gatling doit apparaître

Enregistrer un scénario à l'aide d'un navigateur Web

Gatling se comporte comme un proxy qui lui permet d'enregistrer les requêtes du navigateur et les réponses du serveur.

Nous prenons comme exemple le cas où nous avons en local un serveur Tomcat sur le port 8080.
Gatling écoute sur le port 8000 et redirige les requêtes qu'il reçoit sur le port 8080.
Le navigateur utilise le port 8000 pour envoyer et recevoir les requêtes HTTP sur le proxy.

Ainsi Gatling reçoit les requêtes du navigateur sur le port 8000 et redirige ces requête sur le port 8080 afin que le serveur Tomcat les reçoivent. De même, Gatling reçoit les réponses du serveur Tomcat sur le port 8080 et renvoie les réponses sur le port 8000 pour que le navigateur les reçoivent.

Ce mécanisme permet à Gatling d'enregistrer toutes les requêtes et réponses entre le navigateur et le serveur Tomcat.

Paramétrage de Gatling

Dans la fenêtre d'enregistrement de Gatling :
  • dans la partie Listening Port:
    • HTTP: 8000
    • HTTPS : 8001.
  • dans la partie Outgoing proxy:
    • host : localhost 
    • HTTP : 8080
    • HTTPS : 8081


Paramétrage du navigateur Firefox

Pour Firefox:
  • Menu : Outils > Options > Avancé > Réseau > Paramètres
  • La fenêtre Paramètres de connexion s'affiche
  • Sélectionner Configuration manuelle du proxy
  • Définir :
    • Proxy HTTP : localhost , Port : 8000
    • Décocher la case Utiliser ce proxy pour tous les protocoles
    • Proxy SSL : localhost, Port : 8001
    • Laisser les autres champs vides
    • Vider le champ Pas de proxy pour
  • Valider la saisie et fermer la fenêtre configuration de Firefox

Enregistrer le scénario à l'aide du navigateur

Nous pouvons maintenant enregistrer notre scénario :
  • Dans Firefox, désactiver la configuration manuelle du proxy sur le port 8000
  • Sur Firefox, aller sur la page de début du scénario à enregistrer en utilisant le port 8080
  • Dans Firefox, activer la configuration manuelle du proxy sur le port 8000
  • Sur Gatling, cliquer sur Start pour démarrer l'enregistrement
  • Sur Firefox, changer l'URL dans la barre d'adresse en remplaçant 8080 par 8000 comme port, puis appuyer sur Entrée
  • La page doit apparaître dans Firefox
  • Dans Gatling, des traces indiquent les requêtes HTTP
  • Continuer les actions du scénario
  • Pour arrêter l'enregistrement, revenir sur Gatling et cliquer sur Stop & Save
  • Le scénario a été enregistré
  • Dans Firefox, désactiver la configuration manuelle du proxy sur le port 8000
  • Dans l'IDE, aller dans le répertoire src/test/scala/ et rechercher l'objet RecordedSimulation
  • L'objet RecordedSimulation contient le scénario qui vient d'être enregistré
  • L'enregistreur a pris en compte le paramétrage du proxy dans l'enregistrement :
    • Modifier le code de RecordedSimulation.scala :
      • remplacer :

      • par :
De plus, changer les libellés request_[nb] par un libellé plus parlant au niveau de la requête. Cela permettra d'avoir des libellés sur les requêtes dans le rapport.

Dans un premier temps, nous n'allons pas personnaliser le scénario afin de tester que le scénario tel que Gatling l'a généré fonctionne bien.

Lancer le scénario de test depuis l'IDE

Dans notre projet Gatling sur notre IDE, nous pouvons lancer le scénario que nous venons de créer.

Le lancement depuis l'IDE permet de tester les scénarios que nous sommes en train de créer. L'idéal est ensuite de lancer ces scénarios sans l'IDE, c'est à dire via le programme Gatling pour éviter que l'IDE perturbe les tests.

Pour lancer le scénario depuis l'IDE :
  • Dans le répertoire src/test/scala, lancer l'exécution de Engine.scala
  • La console de l'IDE devient le terminal de commandes pour saisir les informations de Gatling :
  • Gatling demande en premier quelle classe scala des scénarios lancer : 
    • nous devons choisir parmi nos classes des scénarios présents dans le répertoire src/test/scala/gatling
  • Choisir le scénario à lancer
  • Gatling demande ensuite l'identifiant du rapport et la description
  • Puis Gatling lance le scénario de test
  • A la fin, il indique le répertoire du rapport
  • Vérifier au niveau de l'application, que les éléments ont bien été créés ou supprimés par le test de Gatling

Définir le type de montée en charge

Nous allons maintenant modifier notre scénario pour simuler plusieurs utilisateurs et plusieurs itérations.

Pour cela, dans notre IDE, dupliquer le fichier RecordedSimulation.scala et le renommer en MySimulation.scala.

Modifier la dernière ligne du scénario, en remplaçant :

par :

Nous pouvons tester ce script sur notre IDE, en exécutant Engine.scala et en choisissant le scénario MySimulation.scala.

Nous pouvons également lancer ce script en ligne de commande sans IDE pour avoir le maximum de ressources systèmes.

Lancer le scénario en ligne de commandes

Pour avoir le maximum de ressources système pour simuler une très forte montée en charge, nous lançons le scénario en ligne de commandes sans IDE. Pour cela, nous avons à installer le programme Gatling, à y copier le fichier Scala de notre scénario et à lancer le scénario de test.

Installation de Gatling

Gatling s'installe à partir d'un fichier ZIP à télécharger à l'adresse suivante :
  • http://gatling-tool.org/
  • Télécharger le ZIP de la version voulue
  • Dézipper le ZIP sur un répertoire local, comme par exemple : C:\Progs

Lancement du scénario

Nous allons lancer en ligne de commandes le programe Gatling et sélectionner notre scénario de test écrit dans le fichier scala :

  • Dans le répertoire user-files\simulation de Gatling, créer un nouveau répertoire portant le nom de l'application à tester. Dans notre exemple, le répertoire s'appelle books
  • Copier dans ce répertoire le fichier MySimulation.scala
  • Ouvrir un terminal de commande
  • Dans le terminal, lancer le programme bin\gatling.bat
  • Gatling demande quelle simulation lancer :
    • Nous devons voir la simulation que nous venons d'ajouter dans le répertoire
  • Choisir le scénario
  • Saisir ensuite le nom du rapport et la description
  • Gatling lance le scénario de test
  • Il génère le rapport dans le répertoire results\[identifiant]-[timestamp]
  • Ouvrir le fichier index.html de ce répertoire pour voir le rapport de test

Exemple de scénario

Prenons comme exemple, une application qui contient une liste de livres.

Scénario

Le scénario de test contient les étapes suivantes :
  • L'utilisateur accède à la page d'accueil de l'application
  • Il consulte la page contenant la liste de tous les livres sans pagination
  • Il accède à la page de création d'un livre
  • Il crée un nouveau livre

Code Scala du scénario

Voici le code Scala du scénario de création des livres :
Voici le code de définition de la montée en charge :

La définition du setUp indique que 20 utilisateurs effectuent une création d'un livre par seconde pendant 3 minutes. Ce qui revient à 3600 créations de livres.

Résultat

Le rapport indique bien une progression du temps d'accès à la page affichant la liste de tous les livres ce qui est normal car il y a de plus en plus de livres créés :


Conclusion

Gatling permet une plus forte souplesse dans l'écriture des scénarios en permettant de le programmer en Scala. L'archetype Maven permet de démarrer rapidement un projet dans eclipse ou intellijidea.

Les plugins Maven et Jenkins permettent d'inclure les tests de performance dans le processus d'intégration continue.

Le projet Gatling devrait finaliser la version 2.0 durant l'année 2014.

L'évolution de Gatling est à suivre sur Github à l'adresse suivante : http://gatling-tool.org/

Ressources

Libellés : , , , , , , , ,