# k6, Artillery ou Gatling : trois outils pour simuler une montée de trafic

> Trois outils de test de charge, trois philosophies. Comparatif sur la courbe d'apprentissage, le format des scénarios et l'intégration en intégration continue.

- Auteur : WordPress Développement
- Publié le : 2023-03-16
- Mis à jour le : 2023-03-16
- Catégorie : Tests
- URL : https://www.wpmoderne.fr/tests/comparatif-k6-artillery-gatling-montee-trafic/

## L’essentiel

- k6 pour une équipe déjà à l'aise avec JavaScript
- Artillery pour un scénario YAML rapide à écrire
- Gatling pour une charge élevée avec un besoin de rapports détaillés

Trois outils, trois langages de scénario, trois publics différents : k6 s'écrit en JavaScript, Artillery en YAML, Gatling en Scala ou en DSL Java. Pour une équipe qui doit choisir un outil de test de charge avant de simuler un pic de trafic annoncé, ce choix initial pèse plus lourd qu'il n'y paraît sur la vitesse de mise en route et la maintenabilité des scénarios.

Ce comparatif s'appuie sur l'expérience de mise en place des trois outils sur un projet d'annuaire professionnel avant une campagne de communication nationale, sans entrer dans le détail de l'écriture d'un scénario ni dans la mesure côté serveur (OPcache, PHP-FPM), qui fait l'objet d'un traitement séparé.

## Format des scénarios : trois philosophies

k6 définit ses scénarios en JavaScript, ce qui permet de réutiliser des fonctions, des boucles et des conditions comme dans n'importe quel script :

```
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 50 },
    { duration: '1m', target: 200 },
    { duration: '30s', target: 0 },
  ],
};

export default function () {
  const reponse = http.get('https://exemple.test/annuaire/recherche?q=plombier');
  check(reponse, { 'statut 200': (r) => r.status === 200 });
  sleep(1);
}
```

Artillery privilégie un fichier YAML déclaratif, plus rapide à lire pour quelqu'un qui ne programme pas au quotidien :

```
config:
  target: "https://exemple.test"
  phases:
    - duration: 30
      arrivalRate: 5
    - duration: 60
      arrivalRate: 20
scenarios:
  - flow:
      - get:
          url: "/annuaire/recherche?q=plombier"
```

Gatling, de son côté, repose sur une DSL Scala pensée pour composer des scénarios complexes avec des injections de charge variées, mais impose une familiarité avec l'environnement Java/Scala pour aller au-delà des exemples de base.

## Courbe d'apprentissage

> L'essentiel à retenir : k6 pour une équipe déjà à l'aise avec JavaScript ; Artillery pour un scénario YAML rapide à écrire ; Gatling pour une charge élevée avec un besoin de rapports détaillés

| Outil | Langage des scénarios | Temps pour un premier scénario fonctionnel |
| --- | --- | --- |
| k6 | JavaScript | Rapide pour une équipe déjà familière avec Node.js |
| Artillery | YAML | Très rapide, mais limité dès qu'une logique conditionnelle est nécessaire |
| Gatling | Scala / DSL Java | Plus long, nécessite un environnement JVM installé et configuré |

Sur ce projet, l'équipe maîtrisait déjà JavaScript côté front, ce qui a rendu la prise en main de k6 immédiate. Artillery aurait probablement suffi pour le scénario de départ, mais serait devenu contraignant dès qu'il aurait fallu enchaîner une recherche puis une consultation de fiche avec des données extraites de la réponse précédente.

## Intégration en intégration continue

Les trois outils s'intègrent en ligne de commande sans difficulté particulière, chacun proposant une image de conteneur officielle. La différence se joue plutôt sur la sortie exploitée après coup :

- k6 exporte nativement vers InfluxDB, Prometheus ou un format JSON simple, facile à parser dans un script de vérification de seuil.
- Artillery génère un rapport HTML basique, suffisant pour une inspection manuelle mais moins adapté à une automatisation stricte des seuils.
- Gatling produit des rapports HTML très détaillés avec des percentiles précis, appréciés quand le test de charge doit être présenté à un client ou une direction technique.

## Ce que ce comparatif ne tranche pas

Aucun de ces outils n'est objectivement supérieur dans l'absolu : le choix dépend surtout des compétences déjà présentes dans l'équipe et du niveau de détail attendu dans les rapports. Une équipe qui doit justifier un investissement d'infrastructure devant une direction non technique tirera davantage parti des rapports Gatling ; une équipe DevOps déjà outillée en JavaScript ira plus vite avec k6.

> Le meilleur outil de test de charge est celui que l'équipe utilisera vraiment après le premier pic de trafic, pas seulement avant.

## Notre verdict

Pour ce projet d'annuaire professionnel, k6 a été retenu en raison de la proximité avec les compétences JavaScript déjà présentes et de la simplicité d'export vers l'outil de supervision existant. Artillery reste un excellent choix pour un premier scénario ponctuel sans investissement d'apprentissage. Gatling se justifie surtout quand la restitution du rapport compte autant que le test lui-même, par exemple pour valider un dimensionnement d'infrastructure auprès d'un hébergeur.