目录
k6.io简介
官网
概述
k6是一个以开发人员为中心，免费和开源的负载测试工具，旨在使性能测试具有生产力和令人愉悦的体验。
使用k6，能够及早发现性能下降和问题，从而使您能够构建弹性系统和强大的应用程序。
- 具有开发人员友好API的CLI工具。
- JavaScript ES2015 / ES6中的脚本编写-支持本地和远程模块
- 自动化友好的负载测试
- 漂亮的测试报告
Demo
安装
链接如下：
https://k6.io/docs/getting-started/installation
支持linux、Mac、Windows、Docker
一个简单的Demo
复制下面的代码，另存为script.js
import http from 'k6/http';
import { sleep } from 'k6';
//脚本默认入口，至少要有一个，类似于java中的main()方法
//以下的代码会在测试运行期间一遍又一遍地运行，而在外面的代码则是初始化代码
export default function () {
http.get('http://test.k6.io');
sleep(1);
}
win系统下，在当前目录打开命令行界面，运行以下命令
k6 run script.js
第一个简单的Demo就完成了
稍微复杂一点的Demo
import http from 'k6/http';
import { check, sleep } from 'k6';
//options.stages 控制并发
//在执行脚本前30s内，虚拟用户增长至20
//在第30s-1m30s，虚拟用户减少至20
//最后20s，虚拟用户减少至0
export let options = {
stages: [
{ duration: '30s', target: 20 },
{ duration: '1m30s', target: 10 },
{ duration: '20s', target: 0 },
],
};
export default function () {
let res = http.get('https://httpbin.org/');
check(res, { 'status was 200': (r) => r.status == 200 });
sleep(1);
}
运行结果
HTTP请求
GET
上文的两个Demo都是GET，可以参考一下
POST
import http from 'k6/http';
export default function () {
var url = 'http://test.k6.io/login';
var payload = JSON.stringify({
email: 'aaa',
password: 'bbb',
});
var params = {
headers: {
'Content-Type': 'application/json',
},
};
http.post(url, payload, params);
}
DEL
import http from 'k6/http';
const url = 'https://httpbin.test.k6.io/delete';
export default function () {
let params = { headers: { 'X-MyHeader': 'k6test' } };
http.del(url, null, params);
}
PUT
import http from 'k6/http';
const url = 'https://httpbin.test.k6.io/put';
export default function () {
const headers = { 'Content-Type': 'application/json' };
const data = { name: 'Bert' };
let res = http.put(url, JSON.stringify(data), { headers: headers });
console.log(JSON.parse(res.body).json.name);
}
结果可视化
k6.io可以在本地运行测试并将结果流式传输到k6 Cloud
需要结果流式传输到k6 Cloud时，在执行k6命令的机器上运行本地测试，并将结果上传到k6
Cloud。然后，能在Web上实时可视化和分析结果。
Step 1 本地登录k6 Cloud
在官网注册账号后，在本地登录到k6 Cloud，非付费用户最多支持50个虚拟用户并发，并仅支持同时运行一个测试。
登录完成后，点自己的账户信息，在弹出来的菜单栏选择API token，然后将token复制到粘贴板
然后在命令行运行以下脚本
k6 login cloud --token aeadfac95c7d7(这里换成你自己的Token)ae11a1c82c
登录成功会看到如下信息：
Step 2 运行测试并上传结果
写好要测试的脚本后，使用以下命令将k6结果发送到k6 Cloud
k6 run --out cloud script.js
Step 3 查看可视化结果
运行成功的话，控制台将显示一个URL，复制此URL并将其粘贴到浏览器的地址栏中，就可以可视化测试结果。
需要注意的是，一旦脚本开始运行，就可以使用控制台输出的地址访问了，结果是实时传送到K6 cloud的，待脚本执行完毕后，云端才会显示为完成状态，执行过程中云端页面会不断刷新新的结果。
如果你的脚本有输出语句的话，那么很快控制台里面脚本初始化生成的URL就被输出语句刷上去了，因此在脚本刚运行的时候就要把URL保存好，避免找不到地址。
execution: local
output: cloud (https://app.k6.io/runs/721751)
script: script.js
还是蛮好看的
我的案例
请求网页并打印获取到的文件名称
import http from 'k6/http';
import { sleep, check } from 'k6';
import {parseHTML} from "k6/html";
export const options = {
stages: [
{ target: 5, duration: '1m' },
{ target: 10, duration: '1m' },
{ target: 25, duration: '1m' },
{ target: 50, duration: '1m' },
{ target: 0, duration: '1m' },
],
};
export default function() {
const res = http.get("http:******************.html");
const doc = parseHTML(res.body);
sleep(1);
doc.find("link").toArray().forEach(function (item) {
console.log(item.attr("href"));
});
}
结果如下：
测试类型（来自官网）
每种测试类型都旨在为您提供有关系统的不同见解。
冒烟测试的作用是验证您的系统可以处理最小的负载，而不会出现任何问题。
负载测试主要涉及根据并发用户或每秒请求数评估系统性能。
压力测试和峰值测试与评估系统极限以及在极端条件下的稳定性有关。
浸泡测试可以告诉您长时间内系统的可靠性和性能。
要了解的重要一点是，每个测试都可以使用相同的测试脚本执行。您可以编写一个脚本并使用它执行所有上述测试。唯一更改的是测试配置，逻辑保持不变。
不同的测试类型将教给您关于系统的不同知识，并为您提供了解或优化性能所需的见识。
冒烟测试
冒烟测试是常规负载测试，配置为最小负载。在每次编写新脚本或修改现有脚本时都进行冒烟测试，以进行完整性检查。
运行烟雾测试以：
验证测试脚本没有错误。
验证系统在最小负载下没有引发任何错误。
import http from 'k6/http';
import { check, group, sleep, fail } from 'k6';
export let options = {
vus: 1, // 1 user looping for 1 minute
duration: '1m',
thresholds: {
http_req_duration: ['p(99)<1500'], // 99% of requests must complete below 1.5s
},
};
const BASE_URL = 'https://test-api.k6.io';
const USERNAME = 'TestUser';
const PASSWORD = 'SuperCroc2020';
export default () => {
let loginRes = http.post(`${BASE_URL}/auth/token/login/`, {
username: USERNAME,
password: PASSWORD,
});
check(loginRes, {
'logged in successfully': (resp) => resp.json('access') !== '',
});
let authHeaders = {
headers: {
Authorization: `Bearer ${loginRes.json('access')}`,
},
};
let myObjects = http.get(`${BASE_URL}/my/crocodiles/`, authHeaders).json();
check(myObjects, { 'retrieved crocodiles': (obj) => obj.length > 0 });
sleep(1);
};
负载测试
什么是负载测试？
负载测试是一种性能测试，用于确定系统在正常和峰值条件下的行为。
负载测试用于确保许多用户同时访问该应用程序时其性能令人满意。
假设在高峰时段平均看到60个并发用户，而100个用户。
在正常时间和高峰时间都达到性能目标可能很重要，因此建议在配置负载测试时考虑到高负载-在这种情况下为100个用户。
给出负载测试的参数如下，脚本其余部分不变，沿用冒烟测试部分
export let options = {
stages: [
{ duration: '5m', target: 100 }, // simulate ramp-up of traffic from 1 to 100 users over 5 minutes.
{ duration: '10m', target: 100 }, // stay at 100 users for 10 minutes
{ duration: '5m', target: 0 }, // ramp-down to 0 users
],
//用户数从0开始，然后逐渐增加到标称值，并在该标称值上保留很长时间
thresholds: {
http_req_duration: ['p(99)<1500'], // 99% of requests must complete below 1.5s
'logged in successfully': ['p(99)<1500'], // 99% of requests must complete below 1.5s
},
};
模拟正常的一天，配置如下，其余脚本不变：
export let options = {
stages: [
{ duration: '5m', target: 60 }, // simulate ramp-up of traffic from 1 to 60 users over 5 minutes.
{ duration: '10m', target: 60 }, // stay at 60 users for 10 minutes
{ duration: '3m', target: 100 }, // ramp-up to 100 users over 3 minutes (peak hour starts)
{ duration: '2m', target: 100 }, // stay at 100 users for short amount of time (peak hour)
{ duration: '3m', target: 60 }, // ramp-down to 60 users over 3 minutes (peak hour ends)
{ duration: '10m', target: 60 }, // continue at 60 for additional 10 minutes
{ duration: '5m', target: 0 }, // ramp-down to 0 users
],
//在一天中的大部分时间内保持60个用户的使用状态，并在高峰时段运行时增加到100个用户，
//然后再降低到正常负载
thresholds: {
http_req_duration: ['p(99)<1500'], // 99% of requests must complete below 1.5s
},
};
如果系统在负载测试下崩溃，则意味着负载测试已转变为压力测试
压力测试
压力测试是一种负载测试，用于确定系统的限制。该测试的目的是验证系统在极端条件下的稳定性和可靠性。
压力测试应该分多个步骤进行配置，每个步骤都会增加系统的并发负载。
import http from 'k6/http';
import { sleep } from 'k6';
export let options = {
stages: [
{ duration: '2m', target: 100 }, // below normal load
{ duration: '5m', target: 100 },
{ duration: '2m', target: 200 }, // normal load
{ duration: '5m', target: 200 },
{ duration: '2m', target: 300 }, // around the breaking point
{ duration: '5m', target: 300 },
{ duration: '2m', target: 400 }, // beyond the breaking point
{ duration: '5m', target: 400 },
{ duration: '10m', target: 0 }, // scale down. Recovery stage.
],
};
//每2分钟增加100个用户的负载，并在此级别保持5分钟。
//最后，还包括一个恢复阶段，在该阶段，系统逐渐将负载降低到0
export default function () {
const BASE_URL = 'https://test-api.k6.io'; // make sure this is not production
let responses = http.batch([
[
'GET',
`${BASE_URL}/public/crocodiles/1/`,
null,
{ tags: { name: 'PublicCrocs' } },
],
[
'GET',
`${BASE_URL}/public/crocodiles/2/`,
null,
{ tags: { name: 'PublicCrocs' } },
],
[
'GET',
`${BASE_URL}/public/crocodiles/3/`,
null,
{ tags: { name: 'PublicCrocs' } },
],
[
'GET',
`${BASE_URL}/public/crocodiles/4/`,
null,
{ tags: { name: 'PublicCrocs' } },
],
]);
sleep(1);
}
峰值测试
峰值测试是压力测试的一种变体，但它不会逐渐增加负载，而是会在很短的时间范围内达到峰值负载。
给出峰值测试的参数如下，脚本其余部分不变，沿用压力测试部分
export let options = {
stages: [
{ duration: '10s', target: 100 }, // below normal load
{ duration: '1m', target: 100 },
{ duration: '10s', target: 1400 }, // spike to 1400 users
{ duration: '3m', target: 1400 }, // stay at 1400 for 3 minutes
{ duration: '10s', target: 100 }, // scale down. Recovery stage.
{ duration: '3m', target: 100 },
{ duration: '10s', target: 0 },
],
};
//测试从低负载的1分钟开始，然后快速上升到非常高的负载，然后是低负载的恢复期
浸泡测试
负载测试主要与性能评估而言，压力测试涉及在极端条件下系统稳定，浸泡测试则侧重在长时间涉及可靠性。
浸泡测试的持续时间应以小时为单位。建议从1小时的测试开始，一旦成功，则将其扩展到几个小时。有些错误与时间有关，与执行的请求总数无关。
浸泡测试可帮助您发现长时间内出现的错误和可靠性问题。许多复杂的系统都有这种性质的错误。
标准负载测试成功后，应该执行浸泡测试，并且在执行压力测试时发现系统稳定。
浸泡测试是构建可靠系统的最后一步。
import http from 'k6/http';
import { sleep } from 'k6';
export let options = {
stages: [
{ duration: '2m', target: 400 }, // ramp up to 400 users
{ duration: '3h56m', target: 400 }, // stay at 400 for ~4 hours
{ duration: '2m', target: 0 }, // scale down. (optional)
],
};
const API_BASE_URL = 'https://test-api.k6.io';
export default function () {
http.batch([
['GET', `${API_BASE_URL}/public/crocodiles/1/`],
['GET', `${API_BASE_URL}/public/crocodiles/2/`],
['GET', `${API_BASE_URL}/public/crocodiles/3/`],
['GET', `${API_BASE_URL}/public/crocodiles/4/`],
]);
sleep(1);
}
用户流测试（来自官网）
在以下示例中，您将看到四个连续的HTTP请求发送到API，以登录，获取用户配置文件，更新用户配置文件并最终注销。每个请求都有其独特的特征，接受一些参数，最后返回一个response，并根据一组规则进行检查。在每次请求和响应之后，我们也会暂停，以使API能够保持正常运行而不会被淹没。在脚本的开头，我们还添加了一组用于控制脚本的选项。
如您所见，这是一个相当正常但简单的用户流程，它试图模仿使用我们的移动应用程序或网站时的用户行为。为了简单起见，仅显示了四个请求，但是您可以轻松添加其他请求以具有更真实的用户体验。这样，您可以在应用程序或平台中测试用户导航的流程。这一点将k6与大多数当前可用的负载测试工具区分开来，因为它可以用于测试现实的用户流，而不仅仅是依赖锤击一组端点。
import http from 'k6/http';
import { check, sleep } from 'k6';
let options = {
vus: 1000,
duration: '600s',
};
const SLEEP_DURATION = 0.1;
export default function () {
let body = JSON.stringify({
username: 'user_' + __ITER,
password: 'PASSWORD',
});
let params = {
headers: {
'Content-Type': 'application/json',
},
tags: {
name: 'login', // first request
},
};
group('simple user journey', (_) => {
// Login request
let login_response = http.post(
'http://api.yourplatform.com/v2/login',
body,
params,
);
check(login_response, {
'is status 200': (r) => r.status === 200,
'is api key present': (r) => r.json().hasOwnProperty('api_key'),
});
params.headers['api-key'] = login_response.json()['api_key'];
sleep(SLEEP_DURATION);
// Get user profile request
params.tags.name = 'get-user-profile';
let user_profile_response = http.get(
'http://api.yourplatform.com/v2/users/user_' + __ITER + '/profile',
params,
);
sleep(SLEEP_DURATION);
// Update user profile request
body = JSON.string({
first_name: 'user_' + __ITER,
});
params.tags.name = 'update-user-profile';
let update_profile_response = http.post(
'http://api.yourplatform.com/v2/users/user_' + __ITER + '/profile',
body,
params,
);
sleep(SLEEP_DURATION);
// Logout request
params.tags.name = 'logout';
let logout_response = http.get(
'http://api.yourplatform.com/v2/logout',
params,
);
sleep(SLEEP_DURATION);
});
}