Fiche Grafana Kheat : tout ce qu'un ingénieur performance doit savoir

Aide-mémoire Grafana K6 : tout ce qu'un ingénieur de performance doit savoir (avec exemples et meilleures pratiques)

1. Introduction à Grafana K6

Grafana K6 est un outil open source conçu pour les tests de performances. Il est idéal pour tester les API, les microservices et les sites Web à grande échelle, en fournissant aux développeurs et aux testeurs des informations sur les performances du système. Cette aide-mémoire couvrira les aspects clés que tout ingénieur de performance devrait connaître pour démarrer avec Grafana K6.

Qu’est-ce que le Grafana K6 ?

Grafana K6 est un outil de test de charge moderne destiné aux développeurs et aux testeurs qui rend les tests de performances simples, évolutifs et faciles à intégrer dans votre pipeline CI.

Quand l'utiliser ?

• Test de charge
• Tests de résistance
• Tests de pointe
• Détection des goulots d'étranglement des performances
• Tests API
• Test du navigateur
• Ingénierie du chaos

2. Aide-mémoire Grafana K6 : aspects essentiels

2.1. Installation

Installer Grafana K6 via Homebrew ou Docker :

brew install k6
# Or with Docker
docker run -i grafana/k6 run - <script.js

2.2. Test de base avec une API REST publique

Voici comment exécuter un test simple à l'aide d'une API REST publique.

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

// Define the API endpoint and expected response
export default function () {
  const res = http.get("https://jsonplaceholder.typicode.com/posts/1");

  // Define the expected response
  const expectedResponse = {
    userId: 1,
    id: 1,
    title:
      "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    body: "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto",
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });

  sleep(1);
}

2.2.1 Exécution du test et utilisation du tableau de bord Web

Pour exécuter le test et afficher les résultats dans un tableau de bord Web, nous pouvons utiliser la commande suivante :

K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js

Cela générera un rapport dans le dossier des rapports avec le nom html-report.html.

Mais nous pouvons également voir les résultats dans le tableau de bord web en accédant à l'URL suivante :

http://127.0.0.1:5665/

Une fois que nous accédons à l'URL, nous pouvons voir les résultats en temps réel du test dans le tableau de bord Web.

2.3. Tester avec une API publique GraphQL

Exemple d'utilisation d'une API GraphQL publique.

Si vous ne savez pas ce qu'est une API GraphQL, vous pouvez visiter l'URL suivante : Qu'est-ce que GraphQL ?.

Pour plus d'informations sur l'API GraphQL que nous allons utiliser, vous pouvez visiter la documentation de l'URL suivante : GraphQL Pokémon.

Pour plus d'informations sur la façon de tester les API GraphQL, vous pouvez visiter l'URL suivante : GraphQL Testing.

Il s'agit d'un test simple pour obtenir un pokémon par son nom et vérifier si la réponse est réussie.

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

// Define the query and variables
const query = `
  query getPokemon($name: String!) {
    pokemon(name: $name) {
      id
      name
      types
    }
  }`;

const variables = {
  name: "pikachu",
};

// Define the test function
export default function () {
  const url = "https://graphql-pokemon2.vercel.app/";
  const payload = JSON.stringify({
    query: query,
    variables: variables,
  });

  // Define the headers
  const headers = {
    "Content-Type": "application/json",
  };

  // Make the request
  const res = http.post(url, payload, { headers: headers });

  // Define the expected response
  const expectedResponse = {
    data: {
      pokemon: {
        id: "UG9rZW1vbjowMjU=",
        name: "Pikachu",
        types: ["Electric"],
      },
    },
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });
}

3. Bonnes pratiques pour structurer des projets de performance

3.1. Configuration centralisée

Définissez les options de configuration globales telles que les seuils de performances, le nombre d'utilisateurs virtuels (VU) et les durées en un seul endroit pour une modification facile.

brew install k6
# Or with Docker
docker run -i grafana/k6 run - <script.js

3.2. Modularité des codes

3.2.1. Constantes et requêtes pour l'API REST

Séparez le code en modules réutilisables, par exemple en séparant les constantes et les requêtes de la logique de test.

Pour notre exemple d'API REST, nous pouvons créer un fichier constants.js pour stocker l'URL de base de l'API et un fichier requêtes-jsonplaceholder.js pour stocker les fonctions permettant d'interagir avec l'API.

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

// Define the API endpoint and expected response
export default function () {
  const res = http.get("https://jsonplaceholder.typicode.com/posts/1");

  // Define the expected response
  const expectedResponse = {
    userId: 1,
    id: 1,
    title:
      "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    body: "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto",
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });

  sleep(1);
}

Nous pouvons maintenant créer le fichier request-jsonplaceholder.js pour stocker les fonctions permettant d'interagir avec l'API.

K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js

3.2.2. Intégration des Requêtes dans le Script de Test de l'API REST

Enfin, nous pouvons créer notre script de test jsonplaceholder-api-rest.js pour utiliser les fonctions que nous avons créées dans le fichier request-jsonplaceholder.js.

http://127.0.0.1:5665/

Notre code de script est désormais beaucoup plus simple à comprendre, et si quelque chose change dans l'URL, les paramètres ou si une nouvelle méthode doit être ajoutée, l'endroit où les modifications doivent être apportées est centralisé, ce qui rend notre solution plus simple à étendre au fil du temps.

Nous pourrions encore améliorer nos scripts en créant davantage de fonctions atomiques que nous pourrons réutiliser pour créer des scénarios plus complexes à l'avenir si nécessaire, il devient plus simple de comprendre ce que fait notre script de test. Par exemple, si nous voulions tester l'existence d'une publication, nous pourrions créer une fonction qui récupère une publication et renvoie la réponse, puis nous pourrions utiliser cette fonction dans notre script de test jsonplaceholder-api-rest.js.

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

// Define the query and variables
const query = `
  query getPokemon($name: String!) {
    pokemon(name: $name) {
      id
      name
      types
    }
  }`;

const variables = {
  name: "pikachu",
};

// Define the test function
export default function () {
  const url = "https://graphql-pokemon2.vercel.app/";
  const payload = JSON.stringify({
    query: query,
    variables: variables,
  });

  // Define the headers
  const headers = {
    "Content-Type": "application/json",
  };

  // Make the request
  const res = http.post(url, payload, { headers: headers });

  // Define the expected response
  const expectedResponse = {
    data: {
      pokemon: {
        id: "UG9rZW1vbjowMjU=",
        name: "Pikachu",
        types: ["Electric"],
      },
    },
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });
}

3.2.3. Constantes et requêtes pour l'API GraphQL

Nous pouvons modifier le fichier constants.js pour ajouter l'URL de base de l'API GraphQL et les en-têtes que nous devons utiliser.

// ./src/config/options.js
export const options = {
  stages: [
    { duration: '1m', target: 100 }, // ramp up to 100 VUs
    { duration: '5m', target: 100 }, // stay at 100 VUs for 5 mins
    { duration: '1m', target: 0 },   // ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests should complete in under 500ms
  },
};

Nous pouvons maintenant créer le fichier request-graphql-pokemon.js pour stocker les fonctions permettant d'interagir avec l'API GraphQL.

// ./src/utils/constants.js
export const BASE_URLS = {
  REST_API: 'https://jsonplaceholder.typicode.com',
};

3.2.4. Intégration des requêtes dans le script de test de l'API GraphQL

À ce moment, nous pouvons créer notre script de test pour utiliser les fonctions que nous avons créées dans le fichier request-graphql-pokemon.js. Nous allons créer un script de test simple qui obtiendra les données d'un Pokémon et vérifiera si la réponse est réussie.

// ./src/utils/requests-jsonplaceholder.js
import { BASE_URLS } from './constants.js';
import http from 'k6/http';

export function getPosts() {
    return http.get(`${BASE_URLS.REST_API}/posts`);
}

export function getPost(id) {
    return http.get(`${BASE_URLS.REST_API}/posts/${id}`);
}

export function createPost(post) {
    return http.post(`${BASE_URLS.REST_API}/posts`, post);
}

export function updatePost(id, post) {
    return http.put(`${BASE_URLS.REST_API}/posts/${id}`, post);
}

export function deletePost(id) {
    return http.del(`${BASE_URLS.REST_API}/posts/${id}`);
}

De la même manière que pour l'exemple d'api rest, nous pouvons améliorer notre script en créant plus de fonctions atomiques que nous pourrons réutiliser pour créer des scénarios plus complexes dans le futur si nécessaire, cela devient plus simple de comprendre ce qu'est notre script de test fait.

Il existe encore une meilleure façon d'optimiser et d'avoir un meilleur paramétrage des résultats de réponse et de requête, qu'imaginez-vous que nous pourrions faire ?

3.3. Données dynamiques et paramétrage

Utilisez des données dynamiques pour simuler des scénarios plus réalistes et charger différents ensembles de données. K6 nous permet d'utiliser des tableaux partagés pour charger des données à partir d'un fichier. Les tableaux partagés sont un moyen de stocker des données accessibles à tous les VU.

Nous pouvons créer un fichier users-config.js pour charger les données des utilisateurs à partir d'un fichier JSON users.json.

brew install k6
# Or with Docker
docker run -i grafana/k6 run - <script.js

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

// Define the API endpoint and expected response
export default function () {
  const res = http.get("https://jsonplaceholder.typicode.com/posts/1");

  // Define the expected response
  const expectedResponse = {
    userId: 1,
    id: 1,
    title:
      "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    body: "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto",
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });

  sleep(1);
}

Et ensuite nous pouvons l'utiliser dans notre script de test jsonplaceholder-api-rest.js.

K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js

4. Structure du projet

Une structure de projet bien organisée aide à maintenir et à faire évoluer vos tests. Voici une structure de dossiers suggérée :

http://127.0.0.1:5665/

Cette structure aide à garder votre projet organisé, évolutif et facile à maintenir, en évitant l'encombrement à la racine du projet.

Une autre option serait de regrouper les scripts de test dans des dossiers par fonctionnalité, vous pouvez tester et comparer ce qui a le plus de sens pour votre contexte. Par exemple, si votre projet concerne un portefeuille qui effectue des transactions, vous pourriez avoir un dossier pour chaque type de transaction (dépôt, retrait, transfert, etc.) et à l'intérieur de chaque dossier vous pourriez avoir les scripts de test pour cette transaction spécifique.

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

// Define the query and variables
const query = `
  query getPokemon($name: String!) {
    pokemon(name: $name) {
      id
      name
      types
    }
  }`;

const variables = {
  name: "pikachu",
};

// Define the test function
export default function () {
  const url = "https://graphql-pokemon2.vercel.app/";
  const payload = JSON.stringify({
    query: query,
    variables: variables,
  });

  // Define the headers
  const headers = {
    "Content-Type": "application/json",
  };

  // Make the request
  const res = http.post(url, payload, { headers: headers });

  // Define the expected response
  const expectedResponse = {
    data: {
      pokemon: {
        id: "UG9rZW1vbjowMjU=",
        name: "Pikachu",
        types: ["Electric"],
      },
    },
  };

  // Assert the response is as expected
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response is correct": (r) =>
      JSON.stringify(JSON.parse(r.body)) === JSON.stringify(expectedResponse),
  });
}

Sur ce deuxième exemple, nous avons une structure de données plus complexe, mais nous pouvons toujours réutiliser les mêmes fonctions de requêtes que nous avons créées pour le premier exemple.

Conclusion

Les tests de performances avec K6 sont essentiels pour identifier les goulots d'étranglement et garantir l'évolutivité des applications. En suivant les meilleures pratiques telles que la modularisation du code, la centralisation des configurations et l'utilisation de données dynamiques, les ingénieurs peuvent créer des scripts de tests de performances maintenables et évolutifs.

Gros câlin.

Charly Automatise

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!