scenario场景

主要参考地址 https://k6.io/docs/using-k6/scenarios/
先行概念理解

• vus：可以理解为用户数
• iterations：迭代数，也即执行数量，执行几次

  Per VU iterations场景

  每个VU执行特定的iterations，参数如下
• vus 指定vu数 integer default1
• iterations 迭代数 integer default1
• maxDuration 强制停止前的最大场景持续时间（不包括优雅的停止）string 默认 ‘10m’

  import http from 'k6/http';
  import { sleep } from 'k6';
  
  export const options = {
    discardResponseBodies: true,
    scenarios: {
      contacts: {
        executor: 'per-vu-iterations',
        vus: 10,
        iterations: 20,
        maxDuration: '30s',
      },
    },
  };
  
  export default function () {
    http.get('https://test.k6.io/contacts.php');
    // Injecting sleep
    // Sleep time is 500ms. Total iteration time is sleep + time to finish request.
    sleep(0.5);
  }
  
  //我的写法
  export const options = {
    discardResponseBodies: false,
    scenarios: {
      contacts: {
          executor: 'per-vu-iterations',
          vus: 1,
          iterations: 1,
          maxDuration: '30s',
          exec: 'contacts',
          tags: { my_custom_tag: 'contacts' },
          env: { MYVAR: 'contacts' },
        },
      news: {
          executor: 'shared-iterations',
          iterations: 1,
          exec: 'news',
          tags: { my_custom_tag: 'news' },
          env: { MYVAR: 'news' },
      },
    },
  };
  
  export function contacts() {
    if (__ENV.MYVAR != 'contacts') fail();
    http.get('https://test.k6.io/contacts.php');
  }
  
  export function news() {
    if (__ENV.MYVAR != 'news') fail();
    const url = 'http://xxxxxx/api/gateway/login';
    const payload = JSON.stringify({
      "username": "xxxxx",
      "password": "xxxxx"
    });
  
    const params = {
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json, text/plain, */*'
      },
    };
    const res1 = http.post(url, payload, params);
    console.log(res1.body, "哈哈")
  //   console.log(res1.headers)
  }
  
  
  //以下是选项设置解释
  discardResponseBodies: true,代表忽略请求返回体。在性能测试中可以关闭以节省内存，如果需要校验返回body的内容，则需要改为false
  exec 代表要执行的函数。如果没有则是default function
  tags object特定于此场景的标签

  shared-iterations

  特定数量的 VU 完成固定数量的总迭代
  比如：10个VUe完成100个迭代，最后不是10个VUe每个10迭代，可能第一个VUe是5迭代，而第二个是15.总之总计是100迭代
• vus 指定vu数 integer default1
• iterations 迭代数 integer default1
• maxDuration 强制停止前的最大场景持续时间（不包括优雅的停止）string 默认 ‘10m’

  export const options = {
    discardResponseBodies: true,
    scenarios: {
      contacts: {
        executor: 'shared-iterations',
        vus: 10,
        iterations: 200,
        maxDuration: '30s',
      },
    },
  };

  Constant VUs

  该场景适用于：固定数量的VU，在指定时间内尽可能多的完成迭代数
  必填参数如下：
• duration(required) string no default
• vus integer default 1

  //10个用户在30秒内尽可能多的去执行，看最终能执行几次
  export const options = {
    discardResponseBodies: true,
    scenarios: {
      contacts: {
        executor: 'constant-vus',
        vus: 10,
        duration: '30s',
      },
    },
  };

  Ramping VUs

  该场景适用于：线性变化的VUs，在指定时间内完成尽可能多的迭代数
  必填参数如下：
• stages(required) array default []
• startVUs integer default 1
• gracefulRampDown string ‘30s’

  /*
  此示例安排了一个两阶段测试，在 20 秒内从 0 VU 增加到 10 个 VU，然后在 10 秒内减少到 0 VU
  gracefulRampDown 这个参数个人理解是，在20s内，线性递增10个用户，每个用户都在尽可能的发请求去完成迭代。
  但是到了第20s之后要开始递减了，准备递减的那个用户又可能刚好还没完成迭代（完成请求）
  该参数设置0s，则意味着不管前面用户身上的迭代是否完成，直接中断迭代，减少该模拟用户。
  设置10s，则意味着10s之后，才执行停止AU数。通常设置为0s，且应用于线性递减的场景。
  */
  export const options = {
    discardResponseBodies: true,
    scenarios: {
      contacts: {
        executor: 'ramping-vus',
        startVUs: 0,
        stages: [
          { duration: '20s', target: 10 },
          { duration: '10s', target: 0 },
        ],
        gracefulRampDown: '0s',
      },
    },
  };

  Constant arrival rate（恒定到达率）

  适用场景：保持一定迭代启动率，比如每秒30次迭代（请求）。具体k6如何分配，需要参考Arrival-rate VU allocation

  //以下，每秒30迭代，持续30s，
  export const options = {
    discardResponseBodies: true,
    scenarios: {
      contacts: {
        executor: 'constant-arrival-rate',
  
        // How long the test lasts
        duration: '30s',
  
        // How many iterations per timeUnit
        rate: 30,
  
        // Start `rate` iterations per second
        timeUnit: '1s',
  
        // Pre-allocate VUs
        //提供50个VU供分配，VU越多则分配越容易，VU过少就难保持每秒30迭代
        preAllocatedVUs: 50,
      },
    },
  };

  Ramping arrival rate

  阶段到达率，顾名思义，线性提升（降低）到指定到达率（每秒多少迭代），持续一定时间

  /*从定义的开始起始率startRate，一分钟内每分钟 300 次迭代。
  一分钟后，迭代速率在接下来的两分钟内增加到每分钟 600 次迭代，
  并在此速率下再保持四分钟。在最后两分钟，
  它逐渐下降到每分钟 60 次迭代的目标。*/
  
  export const options = {
    discardResponseBodies: true,
  
    scenarios: {
      contacts: {
        executor: 'ramping-arrival-rate',
  
        // Start iterations per `timeUnit`
        startRate: 300,
  
        // Start `startRate` iterations per minute
        timeUnit: '1m',
  
        // Pre-allocate necessary VUs.
        preAllocatedVUs: 50,
  
        stages: [
          // Start 300 iterations per `timeUnit` for the first minute.
          { target: 300, duration: '1m' },
  
          // Linearly ramp-up to starting 600 iterations per `timeUnit` over the following two minutes.
          { target: 600, duration: '2m' },
  
          // Continue starting 600 iterations per `timeUnit` for the following four minutes.
          { target: 600, duration: '4m' },
  
          // Linearly ramp-down to starting 60 iterations per `timeUnit` over the last two minutes.
          { target: 60, duration: '2m' },
        ],
      },
    },
  };