Grafana K6 ist ein Open-Source-Tool für Leistungstests. Es eignet sich hervorragend zum Testen von APIs, Microservices und Websites in großem Maßstab und bietet Entwicklern und Testern Einblicke in die Systemleistung. Dieser Spickzettel deckt die wichtigsten Aspekte ab, die jeder Performance-Ingenieur kennen sollte, um mit Grafana K6 zu beginnen.
Grafana K6 ist ein modernes Lasttest-Tool für Entwickler und Tester, das Leistungstests einfach, skalierbar und leicht in Ihre CI-Pipeline integrierbar macht.
Installieren Sie Grafana K6 über Homebrew oder Docker:
brew install k6 # Or with Docker docker run -i grafana/k6 run - <script.js
So führen Sie einen einfachen Test mit einer öffentlichen REST-API aus.
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);
}
Um den Test auszuführen und die Ergebnisse in einem Web-Dashboard anzuzeigen, können wir den folgenden Befehl verwenden:
K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js
Dadurch wird im Berichtsordner ein Bericht mit dem Namen html-report.html generiert.
Aber wir können die Ergebnisse auch im Web-Dashboard sehen, indem wir auf die folgende URL zugreifen:
http://127.0.0.1:5665/
Sobald wir auf die URL zugreifen, können wir die Ergebnisse des Tests in Echtzeit im Web-Dashboard sehen.
Beispiel für die Verwendung einer öffentlichen GraphQL-API.
Wenn Sie nicht wissen, was eine GraphQL-API ist, können Sie die folgende URL besuchen: Was ist GraphQL?.
Weitere Informationen zur GraphQL-API, die wir verwenden werden, finden Sie in der Dokumentation der folgenden URL: GraphQL Pokémon.
Weitere Informationen zum Testen von GraphQL-APIs finden Sie unter der folgenden URL: GraphQL Testing.
Dies ist ein einfacher Test, um ein Pokémon anhand seines Namens zu ermitteln und zu überprüfen, ob die Antwort erfolgreich ist.
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),
});
}
Definieren Sie globale Konfigurationsoptionen wie Leistungsschwellenwerte, die Anzahl der virtuellen Benutzer (VU) und Dauer an einem Ort für einfache Änderungen.
brew install k6 # Or with Docker docker run -i grafana/k6 run - <script.js
Teilen Sie den Code in wiederverwendbare Module auf, indem Sie beispielsweise Konstanten und Anforderungen von der Testlogik trennen.
Für unser REST-API-Beispiel können wir eine Datei „constants.js“ zum Speichern der Basis-URL der API und eine Datei „requests-jsonplaceholder.js“ zum Speichern der Funktionen zur Interaktion mit der API erstellen.
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);
}
Jetzt können wir die Datei „requests-jsonplaceholder.js“ erstellen, um die Funktionen für die Interaktion mit der API zu speichern.
K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js
Schließlich können wir unser Testskript jsonplaceholder-api-rest.js erstellen, um die Funktionen zu verwenden, die wir in der Datei „requests-jsonplaceholder.js“ erstellt haben.
http://127.0.0.1:5665/
Unser Skriptcode ist jetzt viel einfacher zu verstehen, und wenn sich etwas an der URL oder den Parametern ändert oder eine neue Methode hinzugefügt werden muss, ist der Ort, an dem die Änderungen vorgenommen werden müssen, zentralisiert, wodurch sich unsere Lösung einfacher erweitern lässt im Laufe der Zeit.
Wir könnten unsere Skripte weiter verbessern, indem wir mehr atomare Funktionen erstellen, die wir bei Bedarf in Zukunft wiederverwenden können, um komplexere Szenarien zu erstellen. Es wird immer einfacher zu verstehen, was unser Testskript tut. Wenn wir beispielsweise die Existenz eines Beitrags testen möchten, könnten wir eine Funktion erstellen, die einen Beitrag abruft und die Antwort zurückgibt. Dann könnten wir diese Funktion in unserem Testskript jsonplaceholder-api-rest.js verwenden.
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),
});
}
Wir können die Datei „constants.js“ ändern, um die Basis-URL der GraphQL-API und die Header hinzuzufügen, die wir verwenden müssen.
// ./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
},
};
Jetzt können wir die Datei „requests-graphql-pokemon.js“ erstellen, um die Funktionen für die Interaktion mit der GraphQL-API zu speichern.
// ./src/utils/constants.js
export const BASE_URLS = {
REST_API: 'https://jsonplaceholder.typicode.com',
};
In diesem Moment können wir unser Testskript erstellen, um die Funktionen zu verwenden, die wir in der Datei „requests-graphql-pokemon.js“ erstellt haben. Wir erstellen ein einfaches Testskript, das die Daten eines Pokémon abruft und prüft, ob die Antwort erfolgreich ist.
// ./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}`);
}
Auf die gleiche Weise wie im Beispiel von API Rest können wir unser Skript verbessern, indem wir mehr atomare Funktionen erstellen, die wir bei Bedarf in Zukunft wiederverwenden können, um komplexere Szenarien zu erstellen. Dadurch wird es immer einfacher, unser Testskript zu verstehen tut.
Es gibt immer noch eine bessere Möglichkeit zur Optimierung und besseren Parametrisierung der Antwort- und Anfrageergebnisse. Was könnten wir Ihrer Meinung nach tun?
Verwenden Sie dynamische Daten, um realistischere Szenarien zu simulieren und verschiedene Datensätze zu laden. Mit K6 können wir gemeinsam genutzte Arrays verwenden, um Daten aus einer Datei zu laden. Gemeinsam genutzte Arrays sind eine Möglichkeit, Daten zu speichern, auf die alle VUs zugreifen können.
Wir können eine Datei „users-config.js“ erstellen, um die Benutzerdaten aus einer JSON-Datei „users.json“ zu laden.
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);
}
Und dann können wir es in unserem Testskript jsonplaceholder-api-rest.js verwenden.
K6_WEB_DASHBOARD=true K6_WEB_DASHBOARD_EXPORT=html-report.html k6 run ./src/rest/jsonplaceholder-api-rest.js
Eine gut organisierte Projektstruktur hilft bei der Wartung und Skalierung Ihrer Tests. Hier ist eine vorgeschlagene Ordnerstruktur:
http://127.0.0.1:5665/
Diese Struktur trägt dazu bei, dass Ihr Projekt organisiert, skalierbar und leicht zu warten ist, und vermeidet Unordnung im Projektstamm.
Eine andere Möglichkeit wäre, Testskripte nach Funktionalität in Ordnern zu gruppieren. Sie können testen und vergleichen, was für Ihren Kontext am sinnvollsten ist. Wenn es bei Ihrem Projekt beispielsweise um eine Wallet geht, die Transaktionen durchführt, könnten Sie einen Ordner für jede Art von Transaktion (Einzahlung, Auszahlung, Überweisung usw.) haben und in jedem Ordner könnten Sie die Testskripte für diese spezifische Transaktion haben.
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),
});
}
In diesem zweiten Beispiel haben wir eine komplexere Datenstruktur, aber wir können immer noch dieselben Anforderungsfunktionen wiederverwenden, die wir für das erste Beispiel erstellt haben.
Leistungstests mit K6 sind entscheidend für die Identifizierung von Engpässen und die Sicherstellung der Anwendungsskalierbarkeit. Durch die Befolgung von Best Practices wie der Modularisierung von Code, der Zentralisierung von Konfigurationen und der Verwendung dynamischer Daten können Ingenieure wartbare und skalierbare Leistungstestskripte erstellen.
Große Umarmung.
Charly Automatiza
Das obige ist der detaillierte Inhalt vonGrafana Kheat-Blatt: Alles, was ein Performance-Ingenieur wissen sollte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
