>Tests de charge avec k6 et Grafana

Apache Bench c’est bien pour un test rapide. Pour du vrai load testing, j’utilise k6. Voici comment je m’en sers avec Grafana pour visualiser les résultats.
La différence entre un benchmark et un load test, c’est la charge réelle : un outil comme Apache Bench envoie des requêtes en rafale, sans scénario, sans montée progressive, sans seuil de validation. k6, lui, simule des utilisateurs virtuels qui exécutent de vrais scénarios, avec une montée en charge maîtrisée et la capacité de faire échouer un build si les performances se dégradent.
Pourquoi k6 ?
- Scriptable en JavaScript : pas un format propriétaire
- Basé sur Go : performant, un seul binaire
- CI/CD friendly : exit code non-zero si les seuils sont dépassés
- Open source : pas de licence
Le script en JavaScript est pour moi le premier argument : pas besoin d’apprendre un DSL propriétaire, tout développeur web peut écrire un scénario de test. Et le fait d’être basé sur Go signifie qu’on obtient un binaire autonome, rapide, qui peut générer des dizaines de milliers de requêtes par seconde depuis une simple machine ou un runner CI.
Installation
# Linux |
Deux options selon le contexte : l’installation native donne un binaire à jour et rapide, tandis que la version Docker est pratique dans une CI ou sur une machine où l’on préfère ne rien installer. Dans les deux cas, l’usage en ligne de commande est identique.
Premier script
import http from 'k6/http'; |
Ce premier script illustre les deux concepts fondateurs de k6. Les stages décrivent comment la charge évolue dans le temps : on monte progressivement à 20 utilisateurs virtuels, on maintient, puis on redescend. Cette montée progressive est essentielle : elle permet d’observer le comportement de l’application au fur et à mesure que la charge augmente, plutôt que de l’écraser d’un coup. Les thresholds définissent des critères de succès objectifs, capables de faire échouer le test s’ils sont dépassés.
Chaque itération de default représente l’action d’un utilisateur virtuel : on fait une requête, on vérifie le statut et le temps de réponse, puis on fait une pause (sleep(1)) pour simuler un humain qui lit avant de cliquer.
Exécution :
k6 run script.js |
Tests avancés
Scénario authentifié
import http from 'k6/http'; |
Un test réaliste ne se contente pas de taper sur une URL : il reproduit un parcours utilisateur complet. Ici, on se connecte, on récupère un token dans la réponse, puis on l’utilise pour accéder à une ressource protégée. C’est ce genre d’enchaînement qui met réellement l’application à l’épreuve, car il exerce l’authentification, la session et l’autorisation en même temps que les endpoints métier.
Test de résistance (spike test)
export const options = { |
Le spike test vise un autre objectif : vérifier que l’application survit à un pic brutal de charge (la sortie d’une vente flash, un article viral, un créneau de réservation). On passe de 100 à 500 utilisateurs en un saut, on maintient, puis on relâche. C’est le test qui révèle les limites des pools de connexions, de la mise en cache ou de l’auto-scaling mal dimensionné.
Visualisation avec Grafana
k6 peut exporter les résultats en temps réel vers Prometheus, et Grafana les affiche :
k6 run --out output-prometheus-remote script.js |
L’export en temps réel change l’expérience : au lieu d’un rapport figé à la fin, on voit la courbe de charge se dessiner pendant le test. C’est particulièrement utile pour corréler un saut de latence avec un pic de charge, en direct.
J’utilise le dashboard officiel k6 qui donne :
- Requêtes par seconde
- Temps de réponse (p50, p95, p99)
- Taux d’erreur
- Utilisateurs virtuels actifs
Le dashboard officiel évite d’avoir à construire ses propres panneaux : tout est déjà là, et on peut le brancher sur son Prometheus en quelques clics. Les percentiles (p50, p95, p99) sont plus parlants que la moyenne : p95 à 500 ms signifie que 95 % des requêtes sont en dessous, ce qui reflète mieux l’expérience réelle qu’une moyenne gonflée par quelques valeurs extrêmes.
Intégration CI/CD
# .github/workflows/load-test.yml |
L’intégration la plus utile est le test planifié. Chaque lundi matin, la CI exécute le scénario de charge. Si un seuil n’est pas atteint, le workflow échoue, et c’est une alerte : quelque chose a régressé pendant le weekend (un déploiement, une augmentation de trafic, un effacement de cache). C’est une vigie automatique de la performance, sans intervention manuelle.
Alternatives et quand les utiliser
| Outil | Usage | Langage |
|---|---|---|
| k6 | Load testing, stress, spike | JS |
| Apache Bench | Test rapide HTTP unique | CLI |
| Locust | Tests Python, distribué | Python |
| wrk | Benchmark HTTP bas niveau | Lua |
k6 couvre 90 % de mes besoins. Pour le reste, j’ajoute Locust quand je dois simuler des comportements métier complexes en Python.
Le choix de l’outil dépend surtout du besoin : Apache Bench pour un test ponctuel en une commande, k6 pour des scénarios reproductibles avec seuils, Locust si l’on travaille déjà en Python et qu’on veut du distribué, wrk pour des benchmarks très bas niveau sur de simples endpoints.
Avec k6 + Grafana, j’ai un aperçu en temps réel de comment mon application se comporte sous charge. Et avec les thresholds, la CI/CD elle-même peut refuser un déploiement qui dégrade les performances.
C’est le point clé : un load test qui ne fait que produire des chiffres sans déclencher d’action n’a qu’une valeur informative. En le branchant sur la CI avec des seuils, on le transforme en garde-fou actif : toute régression de performance devient un échec de pipeline, détecté tôt, avant d’atteindre les utilisateurs.