Cheatsheet: k6

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

export default function () {
  http.get('{{target_url}}');
  sleep(1);
}

k6 run {{script_file}}

k6 run --vus 50 --duration 30s {{script_file}}

k6 run --iterations 100 {{script_file}}

k6 run -e BASE_URL=https://example.com {{script_file}}

k6 run --out json=results.json {{script_file}}

k6 run --out influxdb=http://localhost:8086/k6 {{script_file}}

k6 run --quiet {{script_file}}

k6 run --vus 1 --iterations 1 {{script_file}}

export const options = {
  stages: [
    { duration: '30s', target: 20 }, // ramp up to 20 VUs
    { duration: '1m',  target: 20 }, // hold at 20 VUs
    { duration: '10s', target: 0 },  // ramp down to 0
  ],
};

export const options = {
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests under 500ms
    http_req_failed:   ['rate<0.01'], // error rate under 1%
    checks:            ['rate>0.99'], // 99%+ of checks pass
  },
};

export const options = {
  thresholds: {
    'http_req_duration{name:login}': ['p(95)<300'],
  },
};

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

const res = http.get('{{target_url}}');
check(res, {
  'status is 200': (r) => r.status === 200,
  'body not empty': (r) => r.body.length > 0,
});

import http from 'k6/http';

const payload = JSON.stringify({ name: 'abc' });
const params = { headers: { 'Content-Type': 'application/json' } };
http.post('https://api.example.com/users', payload, params);

import http from 'k6/http';

const responses = http.batch([
  ['GET', 'https://test.k6.io/'],
  ['GET', 'https://test.k6.io/news.php'],
]);

export const options = {
  scenarios: {
    steady: {
      executor: 'constant-arrival-rate',
      rate: 100,
      timeUnit: '1s',
      duration: '1m',
      preAllocatedVUs: 50,
    },
  },
};

constant-vus          -- fixed number of VUs for a duration
ramping-vus           -- VUs ramp per stages (like options.stages)
constant-arrival-rate -- fixed iterations/sec, independent of VU response time
ramping-arrival-rate  -- iteration rate ramps per stages
per-vu-iterations     -- each VU runs a fixed number of iterations
shared-iterations     -- a fixed pool of iterations shared across VUs

http_req_duration

http_req_waiting

http_req_failed

http_reqs

iterations

vus / vus_max

data_sent / data_received

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

const waitingTime = new Trend('waiting_time');

export default function () {
  const res = http.get('{{target_url}}');
  waitingTime.add(res.timings.waiting);
}

Counter -- cumulative count, e.g. new Counter('errors')
Rate    -- percentage of true/false values, e.g. new Rate('success_rate')
Gauge   -- latest value only (not cumulative), e.g. new Gauge('queue_size')

export function setup() {
  // runs once, before VUs start -- e.g. fetch an auth token
  return { token: 'abc123' };
}

export default function (data) {
  // runs per-iteration, per-VU -- data.token is available here
}

export function teardown(data) {
  // runs once, after the test completes
}

Code at the top level of the script (imports, options) runs once per VU during
initialization, before any iterations. Code inside the default function (or
setup/teardown) runs per-iteration. Opening files or requiring modules must
happen in init code -- it is not allowed inside the default function.

import http from 'k6/http';

export function setup() {
  const res = http.post('https://api.example.com/login', JSON.stringify({ user: 'a', pass: 'b' }), {
    headers: { 'Content-Type': 'application/json' },
  });
  return { token: res.json('token') };
}

export default function (data) {
  http.get('https://api.example.com/profile', {
    headers: { Authorization: 'Bearer ' + data.token },
  });
}

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

export default function () {
  group('checkout flow', () => {
    http.get('https://example.com/cart');
    http.post('https://example.com/checkout');
  });
}

import { sleep } from 'k6';

sleep(Math.random() * 3 + 1); // 1-4 second pause, mimics real user pacing

import { SharedArray } from 'k6/data';
import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js';

const users = new SharedArray('users', function () {
  return papaparse.parse(open('./users.csv'), { header: true }).data;
});

export default function () {
  const user = users[Math.floor(Math.random() * users.length)];
}

- name: Run k6 load test
  uses: grafana/k6-action@v0.3.1
  with:
    filename: script.js