Votre application fonctionne parfaitement avec dix utilisateurs. Que se passe-t-il le jour de la vente, avec dix mille ? Tests de charge vs tests de stress décrit deux manières différentes de répondre à cette question, et les mélanger conduit à des tests qui ne prouvent pas ce que vous pensez qu’ils font.

Ce guide explique ce que chacun montre, les types de tests associés et comment lire les résultats. Nous avons effectué le calcul du petit centile ci-dessous sur Python 3.13, avec des nombres simulés. Les scripts k6 sont des exemples illustratifs que nous n’avons pas exécutés, et les comptes d’utilisateurs et les cibles sont inventés, alors remplacez-les par les vôtres. Exécutez ces tests uniquement sur les systèmes que vous possédez ou que vous êtes autorisé à tester, car un trafic important peut ressembler à une attaque et provoquer de véritables pannes.

La réponse courte

Un test de charge demande : pouvons-nous gérer le trafic auquel nous nous attendons et atteindre nos objectifs en le faisant ? Un stress test pose la question suivante : combien pouvons-nous prendre avant d’échouer, comment échouons-nous et à quelle vitesse pouvons-nous nous rétablir ?

Pensez à un pont. Un test de charge fait circuler le nombre prévu de camions et confirme que tout va bien. Un test de résistance continue d’ajouter du poids pour connaître sa limite et savoir s’il donne un avertissement en premier. Heureusement, un logiciel coûte moins cher à briser qu’un pont.

Tests de charge et tests de contrainte côte à côte

Qu’est-ce que le test de charge ?

Les tests de charge simulent le trafic réaliste auquel vous vous attendez et mesurent le comportement du système. Il a besoin d’un objectif de test, par exemple : « avec 500 utilisateurs simultanés, 95 % des demandes de paiement se terminent dans un délai de 800 ms, avec moins de 1 % d’erreurs. »

Voici à quoi cela pourrait ressembler en tant que script k6. Les tests k6 sont écrits en JavaScript et thresholds transforment vos objectifs en résultat de réussite ou d’échec :

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

export const options = {
  stages: [
    { duration: "5m", target: 500 },   // ramp up
    { duration: "20m", target: 500 },  // hold at expected peak
    { duration: "2m", target: 0 },     // ramp down
  ],
  thresholds: {
    http_req_duration: ["p(95)<800"],
    http_req_failed: ["rate<0.01"],
  },
};

export default function () {
  http.get("https://staging.example.com/products");
  sleep(1);   // think time, as real users pause
}

Le sleep compte. Sans temps de réflexion, chaque utilisateur virtuel martèle continuellement le serveur, générant bien plus de trafic que ne le ferait le même nombre de personnes réelles.

Qu’est-ce que les tests de résistance ?

Les tests de résistance vont délibérément au-delà des niveaux attendus. Vous n’essayez pas de réussir. Vous voulez des réponses à des questions telles que :

• À quel niveau les performances commencent-elles à s’effondrer ?
• Quel composant tombe en panne en premier : la base de données, les serveurs d’applications ou un appel tiers ?
• Est-ce qu’il échoue normalement avec des erreurs claires, ou est-ce qu’il plante et perd des données ?
• Est-ce qu’il se rétablit tout seul lorsque le trafic baisse ?

export const options = {
  stages: [
    { duration: "5m", target: 500 },    // expected peak
    { duration: "5m", target: 1000 },   // beyond it
    { duration: "5m", target: 2000 },   // further
    { duration: "5m", target: 4000 },   // likely to break
    { duration: "10m", target: 0 },     // recovery: does it come back?
  ],
};

Cette dernière étape de récupération est souvent oubliée, et elle est peut-être la plus précieuse. Un système qui gère bien les pannes mais ne se rétablit jamais sans un redémarrage manuel signifie toujours une panne que quelqu’un doit réparer au milieu de la nuit. Idéalement, sous une charge extrême, un système devrait abandonner le travail de manière contrôlée, en renvoyant des 503 réponses claires au lieu d’expirer.

Spike, trempage et autres types

Les tests de charge et de contrainte appartiennent à une famille plus large de tests de performances :

Les tests d’immersion détectent des problèmes que les tests courts ne détectent jamais. Une petite fuite de mémoire peut sembler inoffensive pendant vingt minutes et n’interrompre le service qu’au bout de deux jours. Les tests Spike conviennent à des événements tels que les ventes flash, où le trafic ne se développe pas progressivement.

Des indicateurs qui comptent

Pourquoi les moyennes sont trompeuses

Les moyennes cachent la lenteur des requêtes dont se plaignent les vraies personnes. Pour le montrer, nous avons généré 100 temps de réponse simulés, dont 95 étaient rapides (80 à 200 ms) et 5 très lents (2,5 à 4 secondes), puis avons calculé les statistiques communes :

import math, random, statistics

random.seed(3)
times = [random.randint(80, 200) for _ in range(95)] \
      + [random.randint(2500, 4000) for _ in range(5)]

def pct(values, p):
    values = sorted(values)
    return values[math.ceil(p / 100 * len(values)) - 1]

print("avg", round(statistics.mean(times)), "p50", pct(times, 50),
      "p95", pct(times, 95), "p99", pct(times, 99), "max", max(times))

# avg 302 p50 150 p95 199 p99 3740 max 3896

Regardez attentivement ces chiffres. La moyenne de 302 ms ne décrit personne. Les requêtes typiques prenaient environ 150 ms, tandis que les requêtes lentes prenaient plus de 3 secondes. Même p95 semble sain à 199 ms, et seul p99 révèle le problème. Un chiffre comme p95 signifie que 95 % des requêtes ont été aussi rapides ou plus rapides.

Et un pour cent des demandes n’est pas un événement rare. Si une page effectue 50 requêtes, un p99 lent affecte une grande partie des pages vues. Fixez des objectifs sur les percentiles qui comptent pour vous et examinez-en plusieurs ensemble.

Outils

N’importe lequel d’entre eux peut exécuter à la fois des tests de charge et de stress. Choisissez celui qui correspond aux compétences de votre équipe, plutôt que de courir après une liste de fonctionnalités. Pour en utiliser un dans votre pipeline, consultez qu’est-ce que CI/CD.

Comment planifier un test

1. Fixez-vous des objectifs. Utilisez de véritables analyses pour déterminer votre pic de trafic et définir des cibles.
2. Choisissez des parcours. Modélisez un comportement réaliste des utilisateurs, tel que la navigation, la recherche et le paiement, dans des proportions réalistes. Frapper uniquement la page d’accueil ne prouve pas grand-chose.
3. Utilisez un environnement réaliste. Un petit serveur intermédiaire ne peut pas prédire la production. Notez toutes les différences.
4. Préparez les données. Utilisez des volumes réalistes, car une requête rapide sur 100 lignes peut en explorer 10 millions.
5. Avertissez les gens. Informez votre équipe opérationnelle et tout tiers, et ne testez pas de charge un fournisseur de paiement par accident. Moquez-vous des services externes le cas échéant.
6. Commencez petit. Exécutez d’abord un petit test de fumée pour confirmer que votre script fonctionne.
7. Surveillez tout. Sans les métriques du serveur, vous verrez que il a ralenti, mais pas pourquoi.
8. Répétez. Exécutez-le à nouveau après chaque correctif et conservez une base de référence à laquelle comparer.

Lire les résultats

Les bases de données constituent un goulot d’étranglement courant. Si les requêtes constituent le problème, lisez notre guide sur l’optimisation des requêtes SQL. Cette dernière ligne du tableau est un piège important : vérifiez toujours également l’état de la machine générant la charge.

Erreurs courantes

• Confondre les utilisateurs avec les requêtes. Indiquez clairement si une cible signifie des utilisateurs simultanés ou des requêtes par seconde.
• Laisser de côté le temps de réflexion. Cela gonfle le trafic et donne des résultats trompeurs.
• Tests trop tardifs. Une semaine avant le lancement ne laisse pas le temps de résoudre les problèmes d’architecture.
• Utilisation d’un seul point de terminaison. Le trafic réel mélange les lectures, les écritures et les recherches.
• La mise en cache cache tout. Des requêtes répétées identiques peuvent uniquement tester votre cache, alors faites varier les données.
• Test une fois. Les performances changent à chaque version, alors exécutez des tests régulièrement.

Pour conclure

Exécutez des tests de charge pour confirmer que vous pouvez gérer le trafic que vous attendez, et des tests de résistance pour savoir ce qui se passe lorsque vous ne le pouvez pas. Commencez petit : choisissez votre parcours utilisateur le plus important, définissez un objectif clair et exécutez un court test par rapport à la mise en scène avec la surveillance activée. Cette première exécution vous apprend généralement quelque chose et vous pouvez construire à partir de là.

Questions fréquentes

Continuez à apprendre