Variable stage during k6 execution

Grafana k6
1

Hi all,

Is there a feature or a workaround to support dynamic stages in ramping arrival rate executor which means mid way during the test the k6 script can modify the stage or target rps and duration ?
I need it to find a breaking point for my service using a binary search way for which i need to have dynamic stages

2

Hi @vipulkhullar,

Can you provide more details to your use case, a better still a script you are working on with a potential workaround that you are having to use to make k6 do what you want it to do.

It sounds like you want a system whereby it would:

  1. Start a load test with n VUs
  2. When the thresholds or some heuristic has been crossed, it should stop the test and start again where n is half what it was before.
  3. If the test passes and no thresholds or heuristics are crossed, it should start the test again by doubling the VUs.
  4. Repeat this process until it finds a sweet spot where the load test just causes your system to under perform.

Best,
Ankur

3

Hi @ankur ,

yes the idea is same but for i can put in a high number of VUs , I am more interested in changing the stages field . I plan to use ramping arrival rate executor but want to change stages dynamically in between running of executions . Looking at documentation of k6 its not possible to do that

4

Hi @vipulkhullar,

That is correct, there is no way to dynamically change the VU count of an executor during runtime. Can you show me with pseudo code how you would envision this to work? I would expect there to be a need of some sort of heuristic that needs to be met so that the VU count is changed, how would that be scripted into the test?

Best,
Ankur

5

I thought that the PATCH operation in k6’s REST API would generally be the way to do this, but thought I read somewhere that not all executor types are supported.

6

I did do something like this through the use of environment variables. I had users input the start calls per minute, end calls per minute and if they wanted a ramping or constant test and then has the test parse all that info to create scenarios based on them with the following code

const test_type = __ENV.TEST_TYPE || 'constant';
const test_scenario = __ENV.SCENARIO || 'standardStreaming';
const rate = __ENV.RATE || '1';
const duration = __ENV.DURATION || '5'
const startRPM = parseInt(__ENV.START_RPM || '5', 10);
const endRPM = parseInt(__ENV.END_RPM || '20', 10);
let options
if (test_type == "ramping") {
    const stageCount = 9;
    const stageDuration = '2m';
    const interval = (endRPM - startRPM) / stageCount;
    const stages = [];
    stages.push({target: 0, duration: '10s'})
    for (let i = 0; i < stageCount; i++) {
        stages.push({
            target: Math.round(startRPM + interval * i),
            duration: stageDuration
        });
    }
    stages.push({
        target: endRPM,
        duration: stageDuration
    });

    options = {
        setupTimeout: '5m',
        scenarios: {
            rampingScenario: {
                exec: test_scenario,
                executor: 'ramping-arrival-rate',
                startRate: 0,
                timeUnit: '1m',
                preAllocatedVUs: 500,
                maxVUs: 1000,
                stages: stages,
                tags: {
                    testId: `${test_scenario}_${test_type}`,
                },
                gracefulStop: '3m',
            },
        }
    }
} else if (test_type == "constant") {
    options = {
        setupTimeout: '5m',
        scenarios: {
            constantScenario: {
                exec: test_scenario,
                executor: 'constant-arrival-rate',
                duration: `${duration}m`,
                rate: rate,
                timeUnit: '1m',
                preAllocatedVUs: 500,
                maxVUs: 1000,
                tags: {
                    testId: `${test_scenario}_${test_type}`,
                },
                gracefulStop: '3m',
            },
        }
    };
}
options.teardownTimeout = '30m';
export {options};