Guide de prise en main rapide de K6

Présentation

K6 est un utilitaire open-source léger, fonctionnant sous Linux, MacOs ou Windows et développé pour vérifier la capacité d’un website à appréhender la charge de son trafic.

Types de tests

Les tests de performance peuvent être réalisés sur le front-end, le back-end ou en hybride avec le HTTP/1.1 par défaut, le HTTP/2, les WebSockets ou le gRPC.

Il est possible de réaliser 6 types de tests:

Smoke test ou test de fumée: Il permet de valider que le script fonctionne et que le système est opérationnel sous une charge minimale
Average-load test ou test de charge moyenne: il évalue comment le système se comporte sous des conditions normales.
Stress test ou test de stress: Il évalue comment un système se comporte face à ses propres limites, lorsque la charge dépasse la moyenne attendue.
Soak test ou test d’endurance: Il évalue la fiabilité et les performances du système pendant une période étendue
Spike test ou test de pointe: il valide le comportement et la survie du système sous une augmentation de l’activité soudaine, de courte durée et massive.
Breakpoint test ou test de rupture: il augmente graduellement la charge pour identifier la capacité limite du système.

Installation

K6 peut être lancé en local (méthode privilégiée dans ce guide), sur le cloud ou à partir d’un container docker.

Les différentes méthodes d’installation sont détaillées dans le lien suivant: https://k6.io/docs/get-started/installation/

Paramètrage

Le paramètrage se fait à partir d’un petit script en javascript modifiable pour répondre au besoin des tests.

Plusieurs paramètres permettent de personaliser les tests :

Virtual users(VUs) : le nombre de d’utilisateurs virtuels
Iterations : le nombre total de répétitions du script par les «VU»
Throughput : la mesure de la quantité de charge est générée par le test dans le temps, habituellement définit par le numbre de «vu» par seconde, le nombre de requêtes par seconde ou le nombre d’itérations par seconde.
User flows : Les actions réalisées par le script et leur ordre de passage pour imiter plus fidèlement le comportement d’un utilisateur.
Load profile : La forme du trafic généré par le test dans le temps. Il peut inclure les délais (temps de réflection), la montée et la baisse de performance au fur et à mesure du test.
Duration : C'est la durée définie pour réaliser complètement le test.

Les options, les modules

Les options, les modules et le scénario viennent en complément des paramètrages afin d'affiner la manière de réaliser les tests et d’obtenir les résultats.

Liste exhaustive des options : https://k6.io/docs/using-k6/k6-options/reference/
Liste exhaustive des modules : https://k6.io/docs/using-k6/modules/

Les scénarios

Ils permettent de configurer de façon plus granulaire les VU et les itération pour se rappocher le plus possible des comportements habituels des utilisateurs et ainsi modéliser la charge et le trafic dans le temps.

Construction des tests

Les tests sont répartis en 3 catégories :

Metrics (métriques):
- counter (compteur): Somme totale
- Gauge (calibre): Monitore le plus petit, le plus grand et la dernière valeur
- Rates (taux): Monitore la fréquence à laquelle la valeur zero intervient
- Trends (tendance): Calcule les statistiques de valeurs multiples (comme la moyenne, la modalité et le pourcentage)
Check (vérification): Vérifie la condition booléenne (vrai/faux) d’un test (ex: La reponse http est a bien la valeur 200, ...)
Thresholds (seuils): Il s’agit d’un critère de réussite ou d’échec à un test métrique (ex: Moins de 1% de retour négatif de requêtes)

Les commandes

Pour connaître la version de K6

k6 version

Pour obtenir l’aide

k6 help

Le script de base :

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

  export default function () {
    http.get('https://website_a_tester.io');
    sleep(1);
  }

La commande pour lancer le test :

k6 run script.js

Exemples de scripts

Smoke test:

smoke.js

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

export default function () {
  http.get('https://website_a_tester.io');
  sleep(1);
}

Average-load test:

average-load.js

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

export const options = {
  stages: [
    { duration: '30m', target: 100 },
    { duration: '1h', target: 100 },
    { duration: '5m', target: 0 },
  ],};

export default function () {
  http.get('https://website_a_tester.io');
  sleep(Math.random() * 5);
}

Stress test:

stress.js

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

export const options = {
  stages: [
    { duration: '10m', target: 200 },
    { duration: '30m', target: 200 },
    { duration: '5m', target: 0 },
  ],};

export default function () {
  http.get('https://website_a_tester.io');

  sleep(1);
}

Soak test:

soak.js

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

export const options = {
  stages: [
    { duration: '5m', target: 100 },
    { duration: '8h', target: 100 },
    { duration: '5m', target: 0 },
  ],};

export default function () {
  http.get('https://website_a_tester.io');

  sleep(Math.random() * 5);
}

Pike test

pike.js

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

export const options = {
  stages: [
    { duration: '2m', target: 2000 },
    { duration: '1m', target: 0 },
  ],};

export default function () {
  http.get('https://website_a_tester.io');

  sleep(Math.random() * 5);
}

Breakpoint test

breakpoint.js

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

export const options = {
  executor: ‘ramping-arrival-rate’,
  stages: [
    { duration: '2h', target: 20000 },
  ],};

export default function () {
  http.get('https://website_a_tester.io');

  sleep(Math.random() * 5);
}

Les résultats

Les résultats sont affichés par défaut sur la console ou peuvent être enregistré dans un fichier sous les formats JSON ou CSV.

Pour la sauvegarde des résultats du test au format JSON, soit:

Ajouter à la ligne de commande l’instruction suivante:

k6 run script.js --out JSON=output.json

Insérer les lignes ci-dessous dans le fichier de script:

export function handleSummary(data) {
  return {
     'output.json': JSON.stringify(data),
  };
}

Pour la sauvegarde les résultats du test au format CSV, soit:

Ajouter à la ligne de commande l’instruction suivante:

k6 run script.js --out CSV=output.csv

Insérer les lignes ci-dessous dans le fichier de script:

export function handleSummary(data) {
  return {
      'output.csv': CSV.stringify(data),
  };
}

Analyse des résultats

1. Les temps de réponse

Dans la plupart des cas, http_req_duration est la métrique la plus pertinente, car elle inclut:

http_req_sending: temps pris pour envoyer des données au serveur cible
http_req_waiting: temps pris avant que le serveur cible ne réponde à la demande
http_req_receiving: temps pris par le serveur cible pour répondre complètement à K6

2. Les taux d’erreurs

Pour les erreurs, c’est http_req_failed qui est utilisé. Les codes de réponse HTTP entre 200 et 399 sont considérés comme valides alors que les codes de réponse HTTP 4xx et HTTP 5xx sont considérés comme erreur par K6.

Attention ! Le « × » représente les requêtes qui ont réussies, alors que « √ » représente les requêtes qui ont échouées.

3. Le nombre de requêtes

La ligne http_reqs renseigne sur le nombre de «VU» et le nombre de requêtes par seconde.

Cela quantifie la charge que subit le serveur durant le test.

4. La durée de l’itération

Le http_req_duration renseigne sur le temps pris par le script pour obtenir une réponse à une requête HTTP de la part sur serveur cible. Malheureusement, de multiple requêtes HTTP peuvent créer une file d’attente pour le flux d’un utilisateur. Pour connaître le temps nécessaire pour la séquence complète d’un utilisateur, l’iteration_duration est l’indicateur qu’il faut suivre.

Cela donne l’indicateur nécessaire pour valider si le temps de réponse à une requête HTTP est acceptable ou non.

5. Le nombre d’itérations

C’est le nombre de fois total, K6 fait boucler le script, comprenant les itérations de tous les «VU».

Cela mesure la vitesse ou le taux auxquels K6 envoie des messages au serveur cible.

Références

https://k6.io/docs/
https://github.com/grafana/k6-learn