🚀 k6 – Test de Charge "Developer-Centric"

Qu'est-ce que k6 ?

k6 est un outil de test de charge (load testing) open-source, moderne, acquis par Grafana Labs. Il est conçu pour être "Developer-Centric" (axé sur les développeurs).

Philosophie "Tests as Code"

Contrairement à JMeter (basé GUI), k6 adopte une approche "Tests as Code" :

1. Les scénarios de test sont écrits en JavaScript (JS) (ES2015+), ce qui les rend faciles à lire, à versionner (Git) et à intégrer.
2. Le moteur (le "cœur") de k6 est écrit en Go (Golang), le rendant extrêmement performant (binaire unique, faible consommation mémoire).
3. Il est conçu pour le CI/CD (Intégration Continue).

Haute Performance (Event-Loop)

k6 (comme Gatling ou Node.js) utilise un modèle asynchrone (event-loop). Un seul thread peut gérer des centaines d'utilisateurs virtuels (VUs). (JMeter, à l'inverse, utilise un modèle "thread-per-user", beaucoup plus lourd).

Le script (.js) est le cœur de k6. Il a deux "contextes" d'exécution :

import http from 'k6/http';
import { sleep } from 'k6';

// ---------------------------------------------
// 1. CONTEXTE "INIT"
// ---------------------------------------------
// (Exécuté 1 SEULE fois, au début)
// (Utilisé pour importer, charger les fichiers,
//  définir les options)
console.log("Contexte INIT (1 fois)");

export const options = {
  vus: 10,
  duration: '30s',
};

const data = open('./payload.json');

// ---------------------------------------------
// 2. CONTEXTE "VU" (Default Function)
// ---------------------------------------------
// (Exécuté en BOUCLE par chaque VU)
export default function () {
  console.log("Contexte VU (en boucle)");
  
  // La requête (Sampler)
  http.post('https://api.test.com/login', data, {
    headers: { 'Content-Type': 'application/json' },
  });

  // "Think time" (Pause)
  sleep(1); // Pause de 1 seconde
}

Les VUs (Utilisateurs Virtuels) sont l'équivalent des "Threads" dans JMeter. C'est l'unité de concurrence.

Chaque VU est une goroutine (un thread "léger" Go) qui exécute votre export default function () en boucle, de manière indépendante et parallèle.

Modèle Asynchrone

k6 étant basé sur un event-loop Go, les VUs sont très légers en RAM/CPU. Une seule machine (injecteur) peut simuler des dizaines de milliers de VUs (là où JMeter s'effondrerait à 1000-2000 threads).

L'objet options (exporté depuis le contexte init) définit la configuration du test de charge (le "comment").

Options Simples (vus / duration)

Pour un test simple (charge fixe).

// Fait un "Ramp-up" de 10 VUs en 5 sec
// Maintient 10 VUs pendant 30 sec
// Fait un "Ramp-down" à 0 en 5 sec
export const options = {
  vus: 10,
  duration: '30s',
  
  // (Optionnel)
  // rampUp: '5s',
  // rampDown: '5s',
};

Options Avancées (stages)

Pour un test par paliers (voir 4.2).

Options de Critères (thresholds)

Pour définir les SLA (voir 3.3).

export const options = {
  thresholds: {
    'http_req_duration': ['p(95)<500'], // P95 < 500ms
    'http_req_failed': ['rate<0.01'],    // Erreurs < 1%
  },
};

Le module k6/http est le "Sampler" principal pour les tests web.

http.get(url, [params])

import http from 'k6/http';

export default function () {
  const params = {
    headers: {
      'Authorization': 'Bearer 12345',
      'X-My-Header': 'MyValue',
    },
    tags: {
      name: 'GetUsers', // Tag la métrique
    },
  };
  const res = http.get('https://api.test.com/users', params);
}

http.post(url, [body], [params])

import http from 'k6/http';

export default function () {
  const url = 'https://api.test.com/login';
  const payload = JSON.stringify({
    email: 'user@example.com',
    password: '123',
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
    },
  };
  
  const res = http.post(url, payload, params);
}

check() est l'équivalent des "Assertions" (JMeter). C'est ce qui vérifie si la réponse reçue est correcte.

Important : Un check() qui échoue n'arrête pas l'exécution du VU. Il incrémente simplement la métrique checks (en échec).

Exemple de check()

import http from 'k6/http';
import { check } from 'k6';

export default function () {
  const res = http.get('https://api.test.com/users/1');
  
  // 'check' prend la réponse (res) et un objet
  // de vérifications (Titre -> Fonction booléenne)
  check(res, {
    '1. Statut est 200': (r) => r.status === 200,
    
    '2. Le corps contient du texte': (r) => r.body.includes('Alice'),
    
    '3. Le JSON est correct': (r) => {
      // (Test coûteux, uniquement si nécessaire)
      const j = r.json(); 
      return j.id === 1;
    },
  });
}

Résultat (CLI) :

    ✓ 1. Statut est 200
    ✓ 2. Le corps contient du texte
    ✗ 3. Le JSON est correct
      ↳ (r.json().id === 1) returned false

Les Thresholds (Seuils) sont la fonctionnalité la plus importante de k6. C'est ce qui définit les critères de réussite (Pass/Fail) (SLA/SLO) de l'ensemble du test.

Si check() (3.2) vérifie la *correction fonctionnelle*, thresholds vérifie la *performance*.

Syntaxe (dans options)

[métrique]: [conditions (array de strings)]

Exemple Complet

export const options = {
  thresholds: {
    // 1. Métrique Standard (Durée)
    // "p(95)" = 95e percentile. (95% des requêtes
    // doivent être < 500ms).
    'http_req_duration': ['p(95)<500', 'p(99)<1500'],

    // 2. Métrique Standard (Erreurs)
    // "rate" = Taux. (Moins de 1% des requêtes
    // doivent être en échec (non-2xx/3xx)).
    'http_req_failed': ['rate<0.01'],

    // 3. Métrique Standard (Checks)
    // (Plus de 98% de nos "checks" (3.2)
    // doivent réussir).
    'checks': ['rate>0.98'],
    
    // 4. Métrique Custom (voir 5.2)
    // (P90 de notre "Trend" custom < 100ms)
    'my_custom_trend': ['p(90)<100'],
  },
};

Si un seul de ces seuils n'est pas atteint à la fin du test, k6 s'arrêtera avec un code d'erreur (non-zéro), ce qui fera échouer le pipeline CI/CD.

L'objet options simple (vus/duration) est un raccourci. Pour des tests complexes (plusieurs "Thread Groups"), on utilise l'objet scenarios.

Un "Scénario" lie un Exécuteur (Executor) (comment la charge est appliquée) à une fonction JS (ce qu'il faut exécuter).

Types d'Exécuteurs (Executors)

Exemple (2 Scénarios)

export function adminLogin() { /* ... */ }
export function userSearch() { /* ... */ }

export const options = {
  scenarios: {
    // Scénario 1 (Charge de base)
    search_users: {
      executor: 'ramping-vus',
      exec: 'userSearch', // Fonction à appeler
      stages: [
        { duration: '1m', target: 100 },
      ],
    },
    // Scénario 2 (Spike test)
    login_admin: {
      executor: 'per-vu-iterations',
      exec: 'adminLogin',
      vus: 5,
      iterations: 10,
    },
  },
};

L'exécuteur ramping-vus est le plus utilisé pour simuler un test de charge réaliste (montée en charge, palier, descente).

Il est défini par un tableau (array) stages.

Exemple de Scénario (30 min)

export const options = {
  scenarios: {
    my_load_test: {
      executor: 'ramping-vus',
      startTime: '0s',
      
      stages: [
        // 1. Ramp-up (Montée en charge)
        // (De 0 à 100 VUs en 5 minutes)
        { duration: '5m', target: 100 },
        
        // 2. Hold (Palier)
        // (Maintient 100 VUs pendant 20 minutes)
        { duration: '20m', target: 100 },
        
        // 3. Ramp-down (Descente)
        // (De 100 à 0 VUs en 5 minutes)
        { duration: '5m', target: 0 },
      ],
    },
  },
};

En plus du code init (1 fois, 1 thread) et VU (N fois, N threads), k6 offre deux fonctions spéciales pour la préparation et le nettoyage.

Exemple de Cycle de Vie

export function setup() {
  // 1. (Exécuté 1 fois)
  const res = http.post('https://api.test.com/auth', { ... });
  const token = res.json().token;
  
  // 2. Passe le token aux VUs
  return { authToken: token };
}

export default function (data) {
  // 3. (Exécuté N fois)
  // 'data' est { authToken: "..." }
  const params = { headers: { 'Authorization': `Bearer ${data.authToken}` } };
  http.get('https://api.test.com/profile', params);
}

export function teardown(data) {
  // 4. (Exécuté 1 fois)
  // 'data' est { authToken: "..." }
  http.post('https://api.test.com/cleanup', ...);
}

k6 collecte automatiquement un ensemble de métriques système, utilisées pour les thresholds et le résumé final.

Vous pouvez (et devriez) créer vos propres métriques pour mesurer des aspects spécifiques de votre application.

Exemple (Trend)

import { Trend } from 'k6/metrics';

// 1. (Contexte INIT) Définir la métrique (Trend)
const loginTrend = new Trend('login_response_time');

export default function () {
  // 2. (Contexte VU) Ajouter une valeur
  const res = http.post('/login', ...);
  loginTrend.add(res.timings.duration);
}

// 3. (Contexte INIT) Définir un seuil
export const options = {
  thresholds: {
    'login_response_time': ['p(95)<800'], // P95 des logins < 800ms
  },
};

group() est l'équivalent du "Transaction Controller" de JMeter. Il permet de grouper logiquement plusieurs requêtes (Samplers) en une seule action métier.

Fonctionnement

Les métriques (ex: http_req_duration) collectées à l'intérieur du group() sont aussi taguées avec le nom du groupe.

import http from 'k6/http';
import { group, sleep } from 'k6';

export default function () {
  // Action 1: Login
  group('01_Login_Process', function () {
    http.get('https://test.k6.io/login');
    sleep(1);
    const res = http.post('https://test.k6.io/login', ...);
    // (Les métriques de ces 2 requêtes sont taguées
    //  "group:01_Login_Process")
  });

  sleep(5);

  // Action 2: Search
  group('02_Search_Users', function () {
    http.get('https://test.k6.io/search?q=test');
    // (Tagué "group:02_Search_Users")
  });
}

Résultat : Permet de filtrer les résultats (ex: "Quel est le P95 de http_req_duration uniquement pour le groupe '01_Login_Process' ?").

k6 Cloud est la plateforme SaaS (payante) de Grafana Labs, conçue pour gérer et scaler les tests k6.

Fonctionnement

Au lieu de k6 run, vous utilisez k6 cloud :

# Authentification (1 fois)
k6 login cloud

# Exécuter le script sur le Cloud
k6 cloud script.js

Avantages

• Scaling (Distribué) : (L'avantage n°1) Vous n'êtes plus limité par votre injecteur local. Vous pouvez demander à k6 Cloud de simuler 1 Million de VUs depuis 10 régions du monde (AWS, GCP...).
• Dashboards : Fournit une interface web (Grafana) pour analyser les résultats (Pass/Fail, Graphes).
• Historique : Stocke l'historique de tous vos tests (comparaison).
• Intégration CI/CD : Facilite l'intégration dans GitLab/GitHub Actions (ex: "Fail si p95 > 500ms").

k6 (par défaut) ne supporte pas tout (ex: SQL, Kafka). Pour ajouter des protocoles, il faut recompiler le binaire k6 avec des extensions (écrites en Go).

xk6 est l'outil (le "builder") utilisé pour compiler k6 avec ces extensions.

Exemple (k6-sql)

Objectif : Tester une base de données PostgreSQL.

# 1. (Prérequis) Installer Go, Git

# 2. Installer xk6
$ go install go.k6.io/xk6/cmd/xk6@latest

# 3. Compiler un binaire k6 "personnalisé" (avec l'extension sql)
$ xk6 build --with github.com/loadimpact/k6-extension-sql

# (Résultat : un nouveau binaire "k6" est créé)

Script (sql.js)

import sql from 'k6/x/sql';

const db = sql.open('postgres', 'postgres://user:pass@host/db');

export default function () {
  sql.query(db, 'SELECT * FROM users WHERE id=1;');
}

// 4. Exécuter (avec le binaire personnalisé)
$ ./k6 run sql.js

Un script de test de charge "propre" (ex: load-test.js) :

import http from 'k6/http';
import { sleep, check, group } from 'k6';
import { Trend } from 'k6/metrics';

// --- 1. CONTEXTE INIT ---
// (Charger les données, définir les métriques custom)
const loginData = JSON.parse(open('./data/users.json'));
const myCustomTrend = new Trend('custom_api_time');

// --- 2. OPTIONS (La Charge) ---
export const options = {
  // Scénario par paliers
  scenarios: {
    my_scenario: {
      executor: 'ramping-vus',
      stages: [
        { duration: '2m', target: 50 }, // Ramp-up
        { duration: '5m', target: 50 }, // Hold
        { duration: '1m', target: 0 },  // Ramp-down
      ],
    },
  },
  
  // Critères de réussite (SLA/SLO)
  thresholds: {
    'http_req_duration': ['p(95)<1000'], // P95 < 1s
    'http_req_failed': ['rate<0.02'],    // Erreurs < 2%
    'checks': ['rate>0.95'],             // Checks > 95%
    'custom_api_time': ['p(90)<800'],
  },
};

// --- 3. SETUP / TEARDOWN (Optionnel) ---
export function setup() {
  // (Ex: Récupérer un token admin)
  return { token: 'abc123' };
}

// --- 4. VU CODE (Le Scénario) ---
export default function (data) {
  // Utiliser la variable d'environnement (passée par -e)
  const host = __ENV.TARGET_HOST || 'https://test.k6.io';
  
  const params = {
    headers: { 'Authorization': `Bearer ${data.token}` },
  };

  group('01_Homepage', function () {
    const res = http.get(`${host}/`, params);
    
    check(res, {
      'Homepage status 200': (r) => r.status === 200,
    });
    
    myCustomTrend.add(res.timings.duration);
    
    sleep(2); // Think time 2 sec
  });
  
  group('02_Profile_Page', function () {
    // (Autre requête...)
  });
}