Load Testing & Performance Benchmarking (JMeter & k6) · Lektion

Checks, Schwellenwerte und Metriken

Verstehen Sie k6-Checks zur Validierung von Antworten und Schwellenwerte zum Festlegen von Leistungszielen.

Checks, Schwellenwerte und Metriken ist eine kostenlose Load Testing & Performance Benchmarking (JMeter & k6)-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Load Testing & Performance Benchmarking (JMeter & k6)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Load Testing & Performance Benchmarking (JMeter & k6)-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Validate Test Responses

When performance testing, simply sending requests isn't enough. We need to confirm that the server is responding correctly, not just quickly.

This is where checks come in. Checks allow you to validate the content and status of server responses.

Simple k6 Checks

A basic check in k6 confirms a condition about the response. If the condition is false, the check fails, but the test continues.

Here's how to check if an HTTP response status is 200 (OK):

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

export default function () {
  const res = http.get('https://test.k6.io');
  check(res, {
    'status is 200': (r) => r.status === 200,
  });
  console.log(`Status: ${res.status}`);
}

Validate Response Content

You can also check for specific text or data within the response body. This is crucial for ensuring the server provides the expected information.

Let's check if the response body contains a specific string:

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

export default function () {
  const res = http.get('https://test.k6.io');
  check(res, {
    'body contains "k6.io"': (r) => r.body.includes('k6.io'),
  });
  console.log(`Body includes 'k6.io': ${res.body.includes('k6.io')}`);
}

Combine Multiple Checks

It's common to validate several aspects of a single response. You can add multiple conditions within one check() call.

Each condition is a separate check, and k6 will report on each one individually.

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

export default function () {
  const res = http.get('https://test.k6.io');
  check(res, {
    'status is 200': (r) => r.status === 200,
    'body size is > 0': (r) => r.body.length > 0,
    'header Content-Type exists': (r) => r.headers['Content-Type'] !== undefined,
  });
}

Understanding k6 Metrics

k6 automatically collects various performance metrics during a test run. These metrics provide insights into your system's behavior under load.

Metrics include things like response times, data transferred, and the number of virtual users (VUs).

Metrics are quantitative measures of performance.
k6 aggregates these into summaries at the end of a test.
They help identify bottlenecks and performance trends.

Common Built-in Metrics

k6 provides several built-in metrics that are always collected. Some key ones include:

http_req_duration: Total time for HTTP requests.
http_req_failed: Rate of failed HTTP requests (e.g., non-2xx status).
vus: Current number of active virtual users.
iterations: Number of times the default function has run.

import http from 'k6/http';

export default function () {
  http.get('https://test.k6.io');
  // k6 automatically collects metrics like http_req_duration
  // and http_req_failed for this request.
}

Create Custom Metrics

Beyond built-in metrics, you can define your own custom metrics to track specific application logic or business processes.

k6 offers various custom metric types like Counter, Gauge, Trend, and Rate.

import http from 'k6/http';
import { Trend } from 'k6/metrics';

const myCustomTrend = new Trend('my_custom_processing_time');

export default function () {
  const start = Date.now();
  const res = http.get('https://test.k6.io');
  const end = Date.now();
  myCustomTrend.add(end - start); // Add value to custom trend metric
  console.log(`Request took ${end - start}ms`);
}

Set Performance Goals

While checks validate individual responses, thresholds define performance goals for your entire test run, based on aggregated metrics.

If a threshold is breached, the k6 test run will fail, indicating a performance regression or unmet SLA (Service Level Agreement).

Add Thresholds to Your Test

Thresholds are defined in the options object of your k6 script. You specify a metric and a condition it must meet.

Here, we ensure the average response time is below 200ms and less than 1% of requests fail.

import http from 'k6/http';

export const options = {
  thresholds: {
    'http_req_duration{expected_response:true}': ['p(95)<200'], // 95th percentile response time < 200ms
    'http_req_failed': ['rate<0.01'], // less than 1% of requests failed
  },
};

export default function () {
  http.get('https://test.k6.io');
}

Quick Check: k6 Concepts

Which of the following statements about k6 checks and thresholds are TRUE?

Recap: Checks, Thresholds, Metrics

Great job! You've learned how to make your k6 tests more robust and goal-oriented.

Checks validate individual server responses for correctness.
Metrics are quantitative measurements collected during a test run (e.g., response time, error rate).
Thresholds define performance goals based on aggregated metrics, failing the test if conditions aren't met.

Häufig gestellte Fragen

Ist die Lektion „Checks, Schwellenwerte und Metriken“ kostenlos?

Ja — der vollständige Text von „Checks, Schwellenwerte und Metriken“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Load Testing & Performance Benchmarking (JMeter & k6)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Load Testing & Performance Benchmarking (JMeter & k6)-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Checks, Schwellenwerte und Metriken“?

Verstehen Sie k6-Checks zur Validierung von Antworten und Schwellenwerte zum Festlegen von Leistungszielen. Du übst Load Testing & Performance Benchmarking (JMeter & k6) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Load Testing & Performance Benchmarking (JMeter & k6) zu starten?

Keine Vorkenntnisse erforderlich. Load Testing & Performance Benchmarking (JMeter & k6) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Checks, Schwellenwerte und Metriken“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Load Testing & Performance Benchmarking (JMeter & k6)-Lektion Code schreiben und ausführen?

Ja. Jede Load Testing & Performance Benchmarking (JMeter & k6)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Installation und CLI von k6
Grundlegende k6-Skripte schreiben
Checks, Schwellenwerte und Metriken
Gruppen und Tags zum Organisieren von Tests

← Zurück zu Load Testing & Performance Benchmarking (JMeter & k6)