k6 est un programme écrit en Go qui génère du trafic selon un scénario écrit en JavaScript et en collecte les métriques. La version actuelle sur la seconde branche est la 2.2.0 du 10 août 2026, le dépôt grafana/k6 compte environ 31,3 mille étoiles, et la licence est l'AGPL-3.0 dans sa forme littérale, sans exception ajoutée pour la liaison avec d'autre code.
Ce que k6 mesure et ce qu'il ne mesure pas
Le malentendu le plus courant autour de k6 vient du fait qu'un scénario ressemble à un test de bout en bout alors qu'il fait quelque chose de tout à fait différent. Un test de bout en bout vérifie qu'une fonctionnalité marche : il clique sur un bouton, attend un élément, compare du texte. Un test de charge vérifie comment le système se comporte quand plusieurs centaines d'utilisateurs effectuent la même opération en même temps. Le premier répond à la question « est-ce que ça marche », le second à « à quelle intensité ça cesse de marcher ».
k6 appartient à la seconde catégorie et les conséquences se voient dans son architecture. Par défaut, aucun navigateur n'est lancé. k6 envoie les requêtes HTTP directement depuis Go, donc il n'y a ni DOM, ni CSS, ni exécution de scripts côté client, ni mesure du temps de rendu. Ce que tu mesures, c'est le temps de réponse du backend : file d'attente de connexion, négociation TLS, temps jusqu'au premier octet, temps de téléchargement du contenu. Si ton application ralentit à cause d'un bundle JavaScript lourd dans le navigateur, k6 en mode protocole ne le verra pas.
Ici, JavaScript joue le rôle d'un langage de description de scénario plutôt que d'un environnement d'exécution. Le script s'exécute dans Sobek, un interpréteur ECMAScript écrit en Go, pas dans Node. Chaque utilisateur virtuel reçoit une instance séparée de cet interpréteur lancée dans une goroutine, ce qui permet à une seule machine de tenir des milliers de sessions parallèles sans le coût de milliers de processus. Le prix à payer est concret : tu n'as pas accès aux modules intégrés de Node, tu ne peux pas importer un paquet npm arbitraire pendant l'exécution du test, et tout ce dont tu as besoin de l'écosystème npm doit être empaqueté au préalable dans un seul fichier.
Depuis la version 0.57, les fichiers avec l'extension .ts sont pris en charge par défaut. k6 les fait passer par esbuild, qui retire les annotations de types. C'est un retrait, pas une vérification : une erreur de type dans le scénario n'arrêtera pas l'exécution. Si la vérification compte pour toi, tsc --noEmit doit rester séparément dans le pipeline, exactement comme dans tout autre projet TypeScript. Le mode de compatibilité se définit avec le flag --compatibility-mode ou la variable K6_COMPATIBILITY_MODE, et la valeur par défaut extended ne diffère de base que par l'alias de la variable global vers globalThis pour le code repris de Node.
Une règle pratique pour choisir un outil découle de cette séparation. Si la question est « cette fonctionnalité marche-t-elle encore après la dernière modification », la réponse se trouve en dehors de k6. Si la question est « combien de sessions simultanées ce endpoint servira-t-il avant que le quatre-vingt-quinzième percentile dépasse une demi-seconde », k6 est exactement ce qu'il te faut. Les deux types de tests tournent souvent dans le même pipeline, mais ils mesurent des choses différentes, et les confondre mène à des conclusions que tu ne pourras pas défendre.
Version, licence et santé du projet
La numérotation des versions demande un moment d'attention, car deux branches sont maintenues en parallèle. La version 2.0.0 est sortie le 11 mai 2026, la 2.1.0 fin juin et la 2.2.0 le dix août. Deux jours après la 2.2.0, le douze août, la version 1.8.1 est apparue, un correctif sur l'ancienne ligne. Si tu regardes la version la plus récente par date, tu obtiens la 1.8.1 et tu tires la mauvaise conclusion que le projet est revenu d'une version majeure en arrière.
Le passage à la version deux a été un remboursement de dette. Le chemin du module Go est passé de go.k6.io/k6 à go.k6.io/k6/v2, ce qui force un changement d'import dans chaque extension. Les commandes k6 login, k6 pause, k6 resume, k6 scale et k6 status ont disparu, avec l'executor externally-controlled sur lequel elles reposaient, et sans remplacement. Les flags --no-summary et --upload-only ont été supprimés, la prise en charge de options.ext.loadimpact a été remplacée par options.cloud, le module k6/experimental/redis a disparu, et la forme positionnelle k6 cloud script.js a cédé la place à k6 cloud run script.js. Le serveur de contrôle HTTP ne démarre plus par défaut et doit être activé avec le flag --address. La bibliothèque web-vitals a été montée en 5.1.0, ce qui a supprimé la métrique FID dépréciée.
La licence est le point à lire attentivement avant que k6 n'entre dans le dépôt d'une entreprise. Trois sources disent la même chose et aucune ne comporte d'exception. Le fichier LICENSE.md de la branche principale compte six cent soixante lignes de texte littéral de la GNU Affero General Public License version 3, sans section ajoutée accordant une permission supplémentaire de liaison. Le fichier README.md indique clairement que k6 est distribué sous licence AGPL-3.0. L'interface de programmation de GitHub renvoie le même identifiant pour le dépôt. C'est un cas rare d'accord complet, sauf que cet accord concerne la licence à l'effet contagieux le plus fort parmi les licences open source populaires.
En pratique, cela signifie trois choses. Exécuter k6 comme outil dans un pipeline d'intégration continue ne crée aucune obligation, car l'AGPL encadre la distribution et la disponibilité sur le réseau plutôt que la simple utilisation du programme. Construire ton propre binaire k6 avec des extensions et le remettre à l'extérieur de l'organisation, c'est déjà distribuer une œuvre dérivée, donc le code des extensions doit être disponible aux conditions de l'AGPL. Exposer un service où l'utilisateur de quelqu'un d'autre pilote ton k6 modifié via un réseau déclenche la section treize et l'obligation de fournir les sources à cet utilisateur.
Deux éléments autour de k6 portent des licences différentes du cœur et se confondent facilement avec la licence de l'outil lui-même. Le paquet @types/k6 vient de DefinitelyTyped, en version 2.2.0 du 17 août 2026, sous licence MIT. Ce ne sont que des déclarations de types, donc les ajouter à devDependencies n'introduit rien de copyleft dans le projet. L'outil de construction de binaires personnalisés, grafana/xk6, est sous Apache 2.0, et c'est une source fréquente de la fausse conclusion selon laquelle les extensions peuvent rester sous licence permissive. L'Apache 2.0 couvre le constructeur lui-même, pas le produit de son travail. Les extensions elles-mêmes portent de toute façon des licences variées : grafana/xk6-dashboard et grafana/xk6-faker sont en AGPL-3.0, tandis que grafana/xk6-sql est en Apache 2.0.
Il y a aussi une divergence de distribution que tout audit trouvera. Le paquet k6 du registre npm est une coquille vide. Il porte le numéro 0.0.0, a été publié le 13 juin 2017, se décrit comme « Dummy package for autocompleting k6 scripts », déclare AGPL-3.0 dans le champ license, et après décompression de l'archive il contient exactement un fichier, package.json. Il n'y a ni code ni texte de licence dedans. L'archive binaire officielle ressemble à cela : k6-v2.2.0-linux-amd64.tar.gz pèse environ trente mégaoctets et se décompresse en un répertoire contenant un seul exécutable. Aucun fichier de licence n'est à l'intérieur, alors que l'AGPL exige que son texte accompagne les copies transmises. Si tu redistribues cette archive en interne dans ton entreprise, ajoute toi-même LICENSE.md depuis le dépôt.
Installation et premier scénario
k6 s'installe comme un binaire unique, via un gestionnaire de paquets système ou une image de conteneur. L'installation par npm ne fonctionnera pas, pour la raison décrite ci-dessus.
# macOS
brew install k6
# Debian and Ubuntu, after adding the Grafana repository
sudo apt-get install k6
# container, no system installation
docker run --rm -i grafana/k6 run - < script.js
# scaffold for a protocol scenario
k6 new script.js
# scaffold for a browser scenario
k6 new --template browser browser-script.js
# run with options overridden from the command line
k6 run --vus 50 --duration 30s script.js
# single pass, skipping the setup and teardown stages
k6 run --iterations 1 --no-setup --no-teardown script.jsLe scénario le plus simple tient en une douzaine de lignes et montre les trois éléments sur lesquels repose tout test ultérieur : la requête, la vérification de la réponse et le seuil qui décide du résultat.
import http from 'k6/http'
import { check, sleep } from 'k6'
export const options = {
vus: 50,
duration: '2m',
thresholds: {
http_req_duration: ['p(95)<500', 'p(99)<1200'],
http_req_failed: ['rate<0.01'],
checks: ['rate>0.99']
}
}
export default function () {
const res = http.get('https://test.k6.io/contacts.php')
check(res, {
'status 200': (r) => r.status === 200,
'body not empty': (r) => r.body.length > 0
})
sleep(1)
}La fonction check n'interrompt pas l'itération quand une condition échoue. Elle incrémente seulement le compteur de la métrique checks et continue, car un test de charge est censé terminer la mesure plutôt que s'effondrer à la première erreur. Ce qui décide du résultat de l'ensemble de l'exécution, c'est la section thresholds : un seuil dépassé donne un code de sortie non nul, c'est-à-dire un résultat rouge dans le pipeline. Sans seuils, k6 run renvoie zéro même quand la moitié des requêtes sont revenues en erreurs serveur.
Scénarios, executors et seuils
Le couple vus plus duration suffit pour une première mesure et ne suffit à rien d'autre. Les vrais scénarios se définissent dans la section scenarios, où chaque entrée choisit un executor, c'est-à-dire la façon dont la charge est répartie dans le temps. Il existe six executors : shared-iterations, per-vu-iterations, constant-vus, ramping-vus, constant-arrival-rate et ramping-arrival-rate.
La séparation suit une frontière que tu dois comprendre pour que les résultats aient du sens. Les executors fondés sur des utilisateurs virtuels maintiennent un nombre constant de sessions parallèles, donc quand le serveur ralentit, le débit de requêtes baisse tout seul et le test cesse de mesurer ce qu'il devait mesurer. Les executors fondés sur le taux d'arrivée maintiennent un nombre constant d'itérations par seconde quelle que soit la durée de réponse, en allouant un pool d'utilisateurs virtuels pour cela. Pour vérifier si un service survit à trois cents commandes par minute, seule la seconde variante est correcte.
import http from 'k6/http'
import { Trend, Counter } from 'k6/metrics'
import exec from 'k6/execution'
const checkoutDuration = new Trend('checkout_duration', true)
const checkoutErrors = new Counter('checkout_errors')
export const options = {
scenarios: {
browsing: {
executor: 'ramping-vus',
startVUs: 0,
stages: [
{ duration: '2m', target: 100 },
{ duration: '5m', target: 100 },
{ duration: '2m', target: 0 }
],
gracefulRampDown: '30s',
tags: { scenario: 'browsing' }
},
checkout: {
executor: 'constant-arrival-rate',
rate: 300,
timeUnit: '1m',
duration: '9m',
preAllocatedVUs: 60,
maxVUs: 200,
startTime: '30s',
exec: 'checkout'
}
},
thresholds: {
'http_req_duration{scenario:browsing}': ['p(95)<400'],
checkout_duration: ['p(95)<900'],
checkout_errors: ['count<20'],
dropped_iterations: ['count<1']
}
}
export default function () {
http.get('https://test.k6.io/')
}
export function checkout() {
const res = http.post('https://test.k6.io/login.php', {
login: `user_${exec.vu.idInTest}`,
password: 'secret'
})
checkoutDuration.add(res.timings.duration)
if (res.status >= 400) {
checkoutErrors.add(1)
}
}Quelques détails de ce fichier méritent d'être explicités. Le champ exec pointe vers une fonction exportée, donc un seul fichier sert plusieurs profils de trafic indépendants à la fois. Les champs preAllocatedVUs et maxVUs sont obligatoires pour les executors à taux : k6 réserve le pool à l'avance, car créer un nouvel utilisateur virtuel en plein test coûte du temps. La métrique dropped_iterations compte les itérations qui n'ont pas pu démarrer à l'heure faute d'utilisateurs libres, et un seuil dessus est le moyen le moins cher de détecter que le générateur de trafic, plutôt que le système testé, était le goulot d'étranglement. La syntaxe avec accolades dans un nom de seuil le restreint à un tag précis, donc un scénario ne fausse pas le résultat d'un autre.
Métriques personnalisées et sorties de résultats
k6 collecte une vingtaine de métriques intégrées. Les plus utilisées sont http_req_duration, le temps complet de la requête, http_req_waiting, le temps jusqu'au premier octet seul, http_req_failed comme taux d'échec, http_reqs comme compteur, iterations et iteration_duration pour les passages du scénario, vus et vus_max pour la taille de l'équipe, data_received et data_sent pour le volume, plus checks, group_duration et dropped_iterations. S'y ajoutent http_req_blocked, http_req_connecting et http_req_tls_handshaking, qui détaillent le coût de l'établissement de la connexion, et grpc_req_duration pour gRPC.
Les métriques personnalisées s'ajoutent via quatre types du module k6/metrics : Counter pour compter, Gauge pour la dernière valeur, Rate pour une proportion de succès et Trend pour une distribution avec percentiles. Le second argument du constructeur Trend fixe l'interprétation de la valeur comme un temps, ce qui ne change que le formatage dans le résumé.
# event stream to a file, one sample per line
k6 run --out json=raw.json script.js
# write to a time-series database through Prometheus remote write
K6_PROMETHEUS_RW_SERVER_URL=http://localhost:9090/api/v1/write \
k6 run --out experimental-prometheus-remote-write script.js
# export through OpenTelemetry
k6 run --out opentelemetry script.js
# built-in browser dashboard plus an HTML report
K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=report.html k6 run script.js
# narrow down the statistics in the standard output summary
k6 run --summary-trend-stats="min,med,p(95),p(99),max" script.jsLa liste des sorties intégrées couvre json, csv, cloud, influxdb, opentelemetry et experimental-prometheus-remote-write, plus le tableau de bord web piloté par les variables K6_WEB_DASHBOARD, K6_WEB_DASHBOARD_EXPORT, K6_WEB_DASHBOARD_HOST, K6_WEB_DASHBOARD_PORT, K6_WEB_DASHBOARD_OPEN et K6_WEB_DASHBOARD_PERIOD. Deux sorties dont on se souvient encore n'existent plus : kafka a disparu dans la version 0.34.0 et statsd dans la 0.55.0, et au lieu de fonctionner, k6 renvoie un message pointant vers une extension externe. Tout ce qui manque à cette liste, tu le récupères via xk6 en construisant ton propre binaire, et tu retombes alors sur les considérations de licence de la section précédente. Pour corréler un pic de latence avec une exception précise de l'application, il est plus facile de comparer le résultat de k6 aux événements de Sentry que de chercher la cause dans les seuls chiffres.
Le module browser et la frontière du bout en bout
L'exception à la règle « k6 ne lance pas de navigateur » est le module k6/browser, intégré au cœur et qui pilote un vrai navigateur basé sur Chromium via le Chrome DevTools Protocol. L'interface est volontairement proche de ce qu'offre Playwright : browser.newPage, page.goto, page.locator, page.screenshot. Depuis la version 0.52.0, toute l'API est asynchrone, donc presque chaque méthode renvoie une promesse.
import { browser } from 'k6/browser'
import { check } from 'k6'
export const options = {
scenarios: {
ui: {
executor: 'shared-iterations',
vus: 5,
iterations: 20,
options: {
browser: { type: 'chromium' }
}
}
},
thresholds: {
browser_web_vital_lcp: ['p(95)<2500'],
browser_web_vital_cls: ['p(95)<0.1'],
checks: ['rate==1.0']
}
}
export default async function () {
const page = await browser.newPage()
try {
await page.goto('https://test.k6.io/', { waitUntil: 'networkidle' })
const heading = page.locator('h1')
check(await heading.textContent(), {
'heading visible': (t) => t !== null && t.length > 0
})
} finally {
await page.close()
}
}Le module ajoute ses propres métriques : browser_data_received, browser_data_sent, browser_http_req_duration, browser_http_req_failed et un ensemble de Core Web Vitals sous la forme de browser_web_vital_lcp, browser_web_vital_fcp, browser_web_vital_cls, browser_web_vital_inp et browser_web_vital_ttfb. La métrique FID a disparu avec la mise à niveau de la bibliothèque web-vitals dans la version 2.0.0, donc un seuil dessus ne se déclenchera tout simplement pas. Le comportement du navigateur est piloté par les variables K6_BROWSER_HEADLESS, K6_BROWSER_ARGS, K6_BROWSER_EXECUTABLE_PATH, K6_BROWSER_TIMEOUT, K6_BROWSER_IGNORE_DEFAULT_ARGS, K6_BROWSER_DEBUG et K6_BROWSER_TRACES_METADATA. La version 2.2.0 a ajouté chromium.connectOverCDP(), qui rattache le test à une instance de navigateur déjà en cours d'exécution à une adresse WebSocket fournie pendant l'exécution du script.
L'échelle de ce mode est entièrement différente de celle du mode protocole. Une seule instance de Chromium avale des centaines de mégaoctets de mémoire et une fraction notable d'un cœur, donc cinq utilisateurs de navigateur peuvent être plus lourds que cinq cents utilisateurs de protocole. Un dispositif raisonnable garde la charge sur la couche protocole tout en faisant tourner à côté une poignée d'utilisateurs de navigateur, pour mesurer comment les Web Vitals réagissent à cette charge. Pour une régression fonctionnelle ordinaire, le module browser n'est pas le bon outil, et là Cypress ou Playwright lui-même conviendront mieux, ne serait-ce que parce qu'ils ont un rapport d'erreurs et un enregistrement des exécutions plus mûrs.
Grafana Cloud k6 et tarifs
Grafana Cloud k6 est un service où le même script s'exécute depuis les zones de charge du fournisseur et où les résultats arrivent dans un tableau de bord à côté du reste de ta télémétrie. Les commandes sont k6 cloud run script.js et k6 cloud run --local-execution script.js, la seconde variante générant le trafic depuis ta propre machine et n'envoyant que les résultats vers le cloud. Depuis la version 2.2.0, il envoie aussi les logs, sauf si tu ajoutes --no-cloud-logs. La version 2.0.0 a durci deux choses : chaque commande cloud exige une stack explicitement nommée, et l'arrêt d'un test pour une raison autre qu'un seuil dépassé renvoie le code de sortie 97 au lieu de l'ancien zéro.
La facturation se fait en heures d'utilisateurs virtuels, abrégées en VUh. Le plan gratuit coûte zéro et donne cinq cents VUh par mois avec un support communautaire. Le plan Pro dans sa variante en libre-service comporte des frais de plateforme de dix-neuf dollars par mois, qui incluent ces mêmes cinq cents VUh, et tout ce qui dépasse est facturé à l'usage. Le tarif baisse avec le volume : cent cinquante millièmes de dollar par VUh de un à trois mille cinq cents, cent trente-cinq millièmes de trois mille cinq cents à sept mille cinq cents, et cent vingt millièmes au-delà de sept mille cinq cents. Le plan Enterprise n'affiche aucun tarif, et le seul chiffre sur la page est un engagement minimal de vingt-cinq mille dollars par an.
Une conséquence de ce dispositif passe facilement inaperçue : le quota de cinq cents VUh est identique sur le plan gratuit et sur le plan payant, donc dix-neuf dollars par mois achètent un support en heures ouvrées sur cinq jours et le droit de dépasser le quota, plutôt qu'une allocation plus grande. L'unité VUh elle-même peut tromper, car elle n'est ni la durée du test ni le nombre de requêtes. Un test avec cinq cents utilisateurs virtuels pendant douze minutes consomme environ cent VUh, donc une douzaine de passages de ce genre épuise le pool gratuit en un mois.
La dépendance au fournisseur est ici limitée, et c'est un véritable avantage de ce dispositif. Le script reste un fichier JavaScript ordinaire qui s'exécute localement sans aucun compte, et les seules choses qui le lient au cloud sont la section options.cloud et le choix des zones de charge. Partir revient à rediriger la sortie ailleurs et à rétablir tes propres machines génératrices de trafic, par exemple des conteneurs sur Railway ou des nœuds opérateurs dans un cluster.
k6 face aux alternatives
| Caractéristique | k6 | Apache JMeter | Gatling | Locust | Playwright |
|---|---|---|---|---|---|
| Langage de scénario | JavaScript ou TypeScript | XML avec éditeur graphique | Scala, Java ou Kotlin | Python | JavaScript ou TypeScript |
| Moteur d'exécution | Go | JVM | JVM | Python | Node avec un navigateur |
| Lance un navigateur | uniquement via le module browser | non | non | non | toujours, c'est son rôle |
| Modèle de charge | utilisateurs virtuels et taux d'arrivée | threads | utilisateurs virtuels | tâches concurrentes | aucun, un passage à la fois |
| Licence | AGPL-3.0 | Apache 2.0 | Apache 2.0 | MIT | Apache 2.0 |
Le choix se résout vite. Si l'équipe écrit en JavaScript et veut des tests de performance dans le même dépôt que l'application, k6 est le candidat naturel, à condition que l'AGPL soit acceptable. Si une licence copyleft est exclue par la politique de l'entreprise, Gatling et JMeter sous Apache 2.0 restent disponibles. Si le backend est de toute façon en Python, Locust économise un langage dans le projet. Et si ce dont tu as réellement besoin, c'est de vérifier qu'un formulaire fonctionne encore après la dernière modification, ce n'est pas un travail pour un outil de tests de charge mais pour Playwright et un ensemble de tests unitaires dans Vitest.
Erreurs fréquentes
La première est un test sans seuils. Sans section thresholds, le processus se termine toujours avec le code de sortie zéro, donc une telle étape dans un pipeline d'intégration continue est verte quels que soient les résultats. Le minimum raisonnable est un seuil sur http_req_failed et un percentile sur http_req_duration.
La deuxième est de mesurer son propre générateur au lieu du système testé. Quand la machine qui exécute k6 sature un cœur ou sa bande passante, les latences croissantes viennent d'elle et non du serveur. Le symptôme est une métrique dropped_iterations non nulle et un graphique de débit plat malgré un nombre d'utilisateurs en hausse. Le seuil dropped_iterations: ['count<1'] l'attrape immédiatement.
La troisième est de s'accrocher à constant-vus quand la question porte sur des requêtes par seconde. Un nombre constant d'utilisateurs avec des réponses plus lentes baisse le débit de lui-même, donc le test se relâche discrètement exactement quand il devrait pousser. C'est là que constant-arrival-rate ou ramping-arrival-rate ont leur place.
La quatrième est de passer une fonction asynchrone à check ou group. Le check intégré rejette un tel appel avec un message pointant vers la bibliothèque k6-utils, disponible à https://jslib.k6.io/k6-utils/1.6.0/index.js, tandis que group lève simplement une erreur. Dans les tests de navigateur, où presque tout est une promesse, c'est la première chose sur laquelle on bute.
La cinquième est de traiter la prise en charge de TypeScript comme une vérification de types. esbuild retire les annotations sans les vérifier, donc une incohérence de types dans un scénario passe dans k6 run sans un mot.
La sixième est d'essayer d'installer k6 avec npm install k6. Ce paquet est une coquille vide de 2017 sans une seule ligne de code, et il se retrouve encore dans des fichiers package.json de nombreux projets et dans des rapports d'audit de dépendances.
La septième est de comparer les résultats de k6 à ce qu'un utilisateur perçoit. En mode protocole, il n'y a pas de rendu, donc un http_req_duration autour de cent millisecondes ne dit rien sur la rapidité ressentie de la page. Les métriques browser_web_vital_* ou des mesures sur du trafic réel servent à cela.
La huitième est de laisser la couche de données hors de l'analyse. Si un test de charge montre une queue de distribution proche d'une seconde, la cause se trouve généralement dans une requête sans index ou un pool de connexions épuisé vers PostgreSQL plutôt que dans l'application elle-même. Sans métriques de base de données collectées sur la même fenêtre de temps, le résultat de k6 te dit seulement que c'est lent.
FAQ
k6 remplacera-t-il les tests de bout en bout ?
Non. En mode protocole, k6 envoie des requêtes HTTP sans navigateur, donc il ne vérifiera ni la visibilité des éléments ni le comportement des scripts côté client. Le module k6/browser pilote un vrai Chromium et couvre une partie de ce terrain, mais son but est de mesurer les Core Web Vitals sous charge plutôt que la régression fonctionnelle.
La licence AGPL-3.0 empêche-t-elle d'utiliser k6 dans une entreprise au code fermé ?
Exécuter k6 dans un pipeline ne crée aucune obligation, car l'AGPL encadre la distribution et la disponibilité sur le réseau. Des obligations apparaissent dès que tu construis ton propre binaire avec des extensions et que tu le remets à l'extérieur de l'organisation, ou que tu exposes une version modifiée comme service réseau. Les déclarations @types/k6 forment un paquet séparé sous MIT.
Combien d'utilisateurs virtuels une machine peut-elle tenir ?
En mode protocole, chaque utilisateur est une goroutine avec sa propre instance d'interpréteur, donc l'ordre de grandeur est de plusieurs milliers sur un serveur moyen, limité surtout par la mémoire et le nombre de sockets. En mode navigateur, le nombre tombe à un chiffre ou à quelques dizaines, car chaque utilisateur est une instance Chromium séparée.
Puis-je importer un paquet npm dans un scénario ?
Pas directement. Le script s'exécute dans l'interpréteur Sobek écrit en Go et non dans Node, donc les modules intégrés de Node et les paquets de node_modules sont indisponibles à l'exécution. La dépendance doit être empaquetée au préalable dans un seul fichier, ou remplacée par une bibliothèque toute prête de jslib.k6.io.
En quoi le plan gratuit de Grafana Cloud k6 diffère-t-il de Pro ?
Les deux donnent cinq cents heures d'utilisateurs virtuels par mois. Pro ajoute des frais de plateforme de dix-neuf dollars par mois, un support en heures ouvrées sur cinq jours et la facturation de l'usage au-delà du quota à un tarif qui baisse avec le volume. Le plan Enterprise exige un engagement à partir de vingt-cinq mille dollars par an.
Qu'a changé la version 2.0.0 et la migration fait-elle mal ?
Le chemin du module Go est devenu go.k6.io/k6/v2, ce qui concerne les auteurs d'extensions. Côté scripts, options.ext.loadimpact, le module k6/experimental/redis et l'executor externally-controlled ont disparu. Côté ligne de commande, k6 login, k6 pause, k6 resume, k6 scale, k6 status, --no-summary et --upload-only ont disparu. Un scénario de protocole typique s'exécute sans changement.
La documentation se trouve sur le site de Grafana, les tarifs du service cloud sur la page des plans, et le code source dans le dépôt GitHub.