No results for

Powered byAlgolia

Thresholds

sugerir editar

¿Qué es un Threshold?

Thresholds es una funcionalidad que permite definir las expectativas de rendimiento del sistema sometido a prueba. Thresholds establecen el criterio por el cual un test se considera correcto o un error.

Ejemplos de expectativas (Thresholds):

  • El sistema no produce más de un 1% de errores
  • El tiempo de respuesta para el 95% de las solicitudes debe ser inferior a 200ms.
  • El tiempo de respuesta para el 99% de las solicitudes debe ser inferior a 400 ms.
  • El punto final específico debe responder siempre antes de 300ms.
  • Cualquier condición en una métrica personalizada.

Thresholds analizan las métricas de rendimiento y determinan el resultado final de la prueba (pasa/no pasa). Thresholds son esenciales para la automatización de las pruebas de carga.

A continuación se muestra un script de ejemplo que especifica dos thresholds, un evaluando la tasa de errores de peticiones HTTP (http_req_failed) y una que usa el percentil del tiempo de reqspuesta de todas las peticiones ( http_req_duration).

threshold.js
1import http from 'k6/http';
2
3export let options = {
4 thresholds: {
5 http_req_failed: ['rate<0.01'], // http errors should be less than 1%
6 http_req_duration: ['p(95)<200'], // 95% of requests should be below 200ms
7 },
8};
9
10export default function () {
11 http.get('https://test-api.k6.io/public/crocodiles/1/');
12}

Cuando se ejecute el test anterior, el resultado de k6 es similar a:

threshold-output
✓ http_req_duration..............: avg=151.06ms min=151.06ms med=151.06ms max=151.06ms p(90)=151.06ms p(95)=151.06ms
{ expected_response:true }...: avg=151.06ms min=151.06ms med=151.06ms max=151.06ms p(90)=151.06ms p(95)=151.06ms
✓ http_req_failed................: 0.00% ✓ 01

El threshold de peticiones fallidas, específica que queremos que nuestra prueba de carga se considere un fracaso (que resulte en que k6 salga con un código de salida distinto de cero) si el 10% o más de las peticiones resultan en error. El threshold http_req_duration especifica que el 95% de las peticiones deben completarse en 200ms.

Al ejecutar ese script, k6 mostrará algo similar a esto:

  • En el caso anterior, se han cumplido los criterios de ambos thresholds. Se considera que toda la prueba de carga es un pass, lo que significa que k6 saldrá con el código de salida cero.

  • Si alguno de los thresholds ha fallado, la marca de verificación de color verde junto al nombre del threshold (http_req_failed, http_req_duration) se mostrara con una cruz de color rojo en su lugar, y k6 debera generar un código de salida distinto de cero.

Copiar y pegar ejemplos de Thresholds

La forma más rápida de empezar con los thresholds es utilizar las métricas estándares incorporadas en k6. A continuación se muestran algunos ejemplos para copiar y pegar que puede empezar a utilizar de inmediato.

threshold-request-duration.js
1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export let options = {
5 thresholds: {
6 // 90% of requests must finish within 400ms.
7 http_req_duration: ['p(90) < 400'],
8 },
9};
10
11export default function () {
12 let res1 = http.get('https://test-api.k6.io/public/crocodiles/1/');
13 sleep(1);
14}
threshold-error-rate.js
1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export let options = {
5 thresholds: {
6 // During the whole test execution, the error rate must be lower than 1%.
7 // `http_req_failed` metric is available since v0.31.0
8 http_req_failed: ['rate<0.01'],
9 },
10};
11
12export default function () {
13 http.get('https://test-api.k6.io/public/crocodiles/1/');
14 sleep(1);
15}

Múltiples thresholds en una sola métrica

threshold-request-duration.js
1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export let options = {
5 thresholds: {
6 // 90% of requests must finish within 400ms, 95% within 800, and 99.9% within 2s.
7 http_req_duration: ['p(90) < 400', 'p(95) < 800', 'p(99.9) < 2000'],
8 },
9};
10
11export default function () {
12 let res1 = http.get('https://test-api.k6.io/public/crocodiles/1/');
13 sleep(1);
14}

Threshold de duración del grupo

threshold-group-duration.js
1import http from 'k6/http';
2import { group, sleep } from 'k6';
3
4export let options = {
5 thresholds: {
6 'group_duration{group:::individualRequests}': ['avg < 200'],
7 'group_duration{group:::batchRequests}': ['avg < 200'],
8 },
9 vus: 1,
10 duration: '10s',
11};
12
13export default function () {
14 group('individualRequests', function () {
15 http.get('https://test-api.k6.io/public/crocodiles/1/');
16 http.get('https://test-api.k6.io/public/crocodiles/2/');
17 http.get('https://test-api.k6.io/public/crocodiles/3/');
18 });
19
20 group('batchRequests', function () {
21 http.batch([
22 ['GET', `https://test-api.k6.io/public/crocodiles/1/`],
23 ['GET', `https://test-api.k6.io/public/crocodiles/2/`],
24 ['GET', `https://test-api.k6.io/public/crocodiles/3/`],
25 ]);
26 });
27
28 sleep(1);
29}

Threshold Syntax

Los thresholds pueden especificarse en formato corto o completo.

threshold-options.js
1export let options = {
2 thresholds: {
3 metric_name1: [ 'threshold_expression', ... ], // short format
4 metric_name1: [ { threshold: 'threshold_expression', abortOnFail: boolean, delayAbortEval: string }, ], // full format
5 }
6};

La declaración anterior dentro de un script k6 significa que habrá un threshold configurado para la métrica metric_name1. Para determinar si el threshold ha fallado o ha sido superado, se evaluará la cadena threshold_expression. La expresión_threshold debe seguir el siguiente formato.

aggregation_method operator value

Ejemplos:

  • avg < 200 // la duración media no puede ser superior a 200ms
  • count >= 500 // el recuento debe ser mayor o igual a 500
  • p(90) < 300 // El 90% de las muestras debe ser inferior a 300

Una expresión de threshold se evalúa como verdadero o falso.

Cada uno de los cuatro tipos de métrica incluidos en k6 proporciona su propio conjunto de métodos de agregación utilizables en las expresiones de threshold.

Tipo de métricaMétodos agregados
Countercount y rate
Gaugevalue
Raterate
Trendavg, min, max, med and p(N) donde N es un número entre 0,0 y 100,0 que significa el valor del percentil a mirar, por ejemplo, p(99,99) significa el percentil 99,99. La unidad para estos valores es el milisegundos.

Aquí hay un script de muestra (ligeramente artificial) que utiliza todos los diferentes tipos de métricas, y establece diferentes tipos de thresholds para ellos:

thresholds-all.js
1import http from 'k6/http';
2import { Trend, Rate, Counter, Gauge } from 'k6/metrics';
3import { sleep } from 'k6';
4
5export let TrendRTT = new Trend('RTT');
6export let RateContentOK = new Rate('Content OK');
7export let GaugeContentSize = new Gauge('ContentSize');
8export let CounterErrors = new Counter('Errors');
9export let options = {
10 thresholds: {
11 RTT: ['p(99)<300', 'p(70)<250', 'avg<200', 'med<150', 'min<100'],
12 'Content OK': ['rate>0.95'],
13 ContentSize: ['value<4000'],
14 Errors: ['count<100'],
15 },
16};
17
18export default function () {
19 let res = http.get('https://test-api.k6.io/public/crocodiles/1/');
20 let contentOK = res.json('name') === 'Bert';
21
22 TrendRTT.add(res.timings.duration);
23 RateContentOK.add(contentOK);
24 GaugeContentSize.add(res.body.length);
25 CounterErrors.add(!contentOK);
26
27 sleep(1);
28}

Tenemos estos thresholds:

  • Una métrica de tendencia que se alimenta con muestras de tiempo de respuesta, y que tiene los siguientes criterios de threshold:
    • El tiempo de respuesta del percentil 99 debe ser inferior a 300 ms
    • El tiempo de respuesta del percentil 70 debe ser inferior a 250 ms
    • El tiempo de respuesta medio debe ser inferior a 200 ms
    • La mediana del tiempo de respuesta debe ser inferior a 150 ms
    • El tiempo de respuesta mínimo debe ser inferior a 100 ms
  • Una métrica de tasa que lleva la cuenta de la frecuencia con la que el contenido devuelto estaba bien. Esta métrica tiene un criterio de éxito: el contenido debe estar bien más del 95% de las veces.
  • Una métrica de calibre que contiene el último tamaño del contenido devuelto. El criterio de éxito para esta métrica es que el contenido devuelto debe ser menor de 4000 bytes.
  • Una métrica de contador que lleva la cuenta del número total de veces que el contenido devuelto no estaba bien. El criterio de éxito aquí implica que el contenido no puede haber sido malo más de 99 veces.

Thresholds en tags

A menudo es útil especificar thresholds sólo en una única URL o en una etiqueta específica. En k6, las solicitudes etiquetadas crean sub métricas que pueden utilizarse en los thresholds, como se muestra a continuación.

export let options = {
thresholds: {
'metric_name{tag_name:tag_value}': ['threshold_expression'],
},
};

Y aquí hay un ejemplo completo.

thresholds-on-submetrics.js
1import http from 'k6/http';
2import { sleep } from 'k6';
3import { Rate } from 'k6/metrics';
4
5export let options = {
6 thresholds: {
7 'http_req_duration{type:API}': ['p(95)<500'], // threshold on API requests only
8 'http_req_duration{type:staticContent}': ['p(95)<200'], // threshold on static content only
9 },
10};
11
12export default function () {
13 let res1 = http.get('https://test-api.k6.io/public/crocodiles/1/', {
14 tags: { type: 'API' },
15 });
16 let res2 = http.get('https://test-api.k6.io/public/crocodiles/2/', {
17 tags: { type: 'API' },
18 });
19
20 let responses = http.batch([
21 [
22 'GET',
23 'https://test-api.k6.io/static/favicon.ico',
24 null,
25 { tags: { type: 'staticContent' } },
26 ],
27 [
28 'GET',
29 'https://test-api.k6.io/static/css/site.css',
30 null,
31 { tags: { type: 'staticContent' } },
32 ],
33 ]);
34
35 sleep(1);
36}

Abortar una prueba cuando se cruza un thresholds

Si desea abortar una prueba en cuanto se cruza un threshold, antes de que la prueba haya finalizado, existe un formato de especificación de threshold ampliado que tiene el siguiente aspecto:

threshold-abort.js
1export let options = {
2 thresholds: {
3 metric_name: [ { threshold: string, abortOnFail: boolean, delayAbortEval: string }, ... ],
4 }
5};

Como puede ver en el ejemplo anterior, la especificación del thresholds se ha ampliado para admitir alternativamente un objeto JS con parámetros para controlar el comportamiento de la interrupción. Los campos son los siguientes:

NombreTipoDescripción
thresholdstringEs la cadena de expresión de threshold que especifica la condición de threshold a evaluar.
abortOnFailbooleanSi se aborta la prueba si el threshold se evalúa como falso antes de que la prueba haya finalizado.
delayAbortEvalstringSi desea retrasar la evaluación del threshold durante algún tiempo, para permitir que se recojan algunas muestras métricas, puede especificar la cantidad de tiempo a retrasar utilizando cadenas de tiempo relativas como 10s, 1m y así sucesivamente.

A continuación un ejemplo:

abort-on-fail-threshold.js
1import http from 'k6/http';
2
3export let options = {
4 vus: 30,
5 duration: '2m',
6 thresholds: {
7 http_req_duration: [{threshold: 'p(99) < 10', abortOnFail: true}]
8 },
9};
10
11export default function () {
12 http.get('https://test-api.k6.io/public/crocodiles/1/');
13}

⚠️ Retraso de la evaluación en k6 Cloud

Cuando k6 se ejecuta en la nube, los thresholds se evalúan cada 60 segundos, por lo que la función "abortOnFail" puede retrasarse hasta 60 segundos.

Fallo de una prueba de carga mediante comprobaciones

Los checks son buenas para codificar aserciones, pero a diferencia de los thresholds, las checks no afectarán al estado de salida de k6.

Si sólo utilizas checks para verificar que las cosas funcionan como se espera, no podrás suspender toda la prueba basándote en los resultados de esas checks.

A menudo puede ser útil combinar checks y thresholds, para obtener lo mejor de ambos:

check_and_fail.js
1import http from 'k6/http';
2import { check, sleep } from 'k6';
3
4export let options = {
5 vus: 50,
6 duration: '10s',
7 thresholds: {
8 // the rate of successful checks should be higher than 90%
9 checks: ['rate>0.9'],
10 },
11};
12
13export default function () {
14 const res = http.get('http://httpbin.org');
15
16 check(res, {
17 'status is 500': (r) => r.status == 500,
18 });
19
20 sleep(1);
21}

En este ejemplo, el threshold se configura en la métrica de los checks, estableciendo que la tasa de checks con éxito debe ser superior al 90%.

Además, puede utilizar etiquetas en los controles si desea definir un threshold basado en un control o grupo de controles concreto. Por ejemplo:

1import http from 'k6/http';
2import { check, sleep } from 'k6';
3
4export let options = {
5 vus: 50,
6 duration: '10s',
7 thresholds: {
8 'checks{myTag:hola}': ['rate>0.9'],
9 },
10};
11
12export default function () {
13 let res;
14
15 res = http.get('http://httpbin.org');
16 check(res, {
17 'status is 500': (r) => r.status == 500,
18 });
19
20 res = http.get('http://httpbin.org');
21 check(
22 res,
23 {
24 'status is 200': (r) => r.status == 200,
25 },
26 { myTag: 'hola' },
27 );
28
29 sleep(1);
30}

Thresholds en k6 Cloud Results

En los resultados de k6 Cloud los thresholds están disponibles en su propia pestaña para su análisis.

También puede ver cómo se compara la métrica subyacente con un threshold específico a lo largo de la prueba. El threshold puede añadirse a la pestaña de análisis para su posterior comparación con otras métricas.

k6 Cloud Thresholds Tab