Skip to main content
k6-load-testing Comprehensive k6 load testing skill for API, browser, and scalability testing. Write realistic load scenarios, analyze results, and integrate with CI/CD.
الانتقال إلى التثبيت سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
عرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/davila7/claude-code-templates --skill k6-load-testingيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... المزيد من هذا المستودع Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer Use, OpenAI's Operator/CUA, and open-source alternatives. Critical focus on sandboxing, security, and handling the unique challenges of vision-based control. Use when: computer use, desktop automation agent, screen control AI, vision-based agent, GUI automation.
Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into focused tools people will pay for. Not just 'ChatGPT but different' - products that solve specific problems with AI. Covers prompt engineering for products, cost management, rate limiting, and building defensible AI businesses. Use when: AI wrapper, GPT product, AI tool, wrap AI, AI SaaS.
github-workflow-automation Automate GitHub workflows with AI assistance. Includes PR reviews, issue triage, CI/CD integration, and Git operations. Use when automating GitHub workflows, setting up PR review automation, creating GitHub Actions, or triaging issues.
المهن ذات الصلة SOC
استنادا إلى تصنيف SOC المهني
name k6-load-testing description Comprehensive k6 load testing skill for API, browser, and scalability testing. Write realistic load scenarios, analyze results, and integrate with CI/CD. category testing risk safe source community date_added 2026-03-13 author Kairo Official tags ["k6","load-testing","performance","api-testing","ci-cd"] tools ["claude","cursor","gemini"]
k6 Load Testing
Overview
k6 is a modern, developer-centric load testing tool that helps you write and execute performance tests for HTTP APIs, WebSocket endpoints, and browser scenarios. This skill provides comprehensive guidance on writing realistic load tests, configuring test scenarios (smoke, load, stress, spike, soak), analyzing results, and integrating with CI/CD pipelines.
Use this skill when you need to validate system performance, identify bottlenecks, ensure SLA compliance, or catch performance regressions before deployment.
When to Use This Skill
Use when you need to load test HTTP APIs, WebSocket endpoints, or browser scenarios
Use when setting up performance regression tests in CI/CD
Use when analyzing system behavior under various load conditions
Use when comparing performance between code changes
Use when validating SLA requirements and performance budgets
k6 Basics
Installation
brew install k6
choco install k6
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6
Quick Start
import http from 'k6/http' ;
import { check, sleep } from 'k6' ;
export const options = {
vus : 10 ,
duration : '30s' ,
};
export default function (
const
get
'https://httpbin.test.k6.io/get'
check
'status is 200'
(r ) =>
status
200
'response time < 500ms'
(r ) =>
timings
duration
500
sleep
1
Run with: k6 run simple-test.js
Test Configuration
Common Options export const options = {
vus : 100 ,
duration : '5m' ,
stages : [
{ duration : '30s' , target : 20 },
{ duration : '1m' , target : 100 },
{ duration : '30s' , target : 0 },
],
thresholds : {
http_req_duration : ['p(95)<500' ],
http_req_failed : ['rate<0.01' ],
},
ext : {
loadimpact : {
name : 'My Load Test' ,
distribution : {
'amazon:us:ashburn' : { weight : 50 },
'amazon:eu: Dublin' : { weight : 50 },
},
},
},
};
Test Types Type Use Case Configuration Smoke Test Verify basic functionality Low VUs (1-5), short duration Load Test Normal expected load Target VUs based on traffic Stress Test Find breaking point Ramp beyond capacity Spike Test Sudden traffic spikes Rapid increase/decrease Soak Test Long-term stability Extended duration
HTTP Testing
Basic Requests import http from 'k6/http' ;
import { check, sleep } from 'k6' ;
export default function (const getRes = http.get ('https://api.example.com/users' );
check (getRes, {
'GET succeeded' : (r ) => r.status === 200 ,
'has users' : (r ) => r.json ('data.length' ) > 0 ,
});
const postRes = http.post ('https://api.example.com/users' ,
JSON .stringify ({ name : 'Test User' , email : 'test@example.com' }),
{
headers : {
'Content-Type' : 'application/json' ,
'Authorization' : 'Bearer ' + __ENV.API_TOKEN ,
},
}
);
check (postRes, {
'POST succeeded' : (r ) => r.status === 201 ,
'user created' : (r ) => r.json ('id' ) !== undefined ,
});
sleep (1 );
}
Request Chaining import http from 'k6/http' ;
import { check } from 'k6' ;
export default function (const loginRes = http.post ('https://api.example.com/login' ,
JSON .stringify ({ email : 'test@example.com' , password : 'password123' })
);
const token = loginRes.json ('access_token' );
const headers = {
'Authorization' : `Bearer ${token} ` ,
'Content-Type' : 'application/json' ,
};
const profileRes = http.get ('https://api.example.com/profile' , {
headers : headers,
});
check (profileRes, {
'profile loaded' : (r ) => r.status === 200 ,
});
}
Parameterized Testing import http from 'k6/http' ;
import { check } from 'k6' ;
const usernames = ['user1' , 'user2' , 'user3' , 'user4' , 'user5' ];
export default function (const username = usernames[__VU % usernames.length ];
const res = http.get (`https://api.example.com/users/${username} ` );
check (res, {
'user found' : (r ) => r.status === 200 ,
});
}
Browser Testing (k6 Browser) import { browser } from 'k6/browser' ;
export const options = {
scenarios : {
browser_test : {
executor : 'constant-vus' ,
vus : 5 ,
duration : '30s' ,
browser : {
type : 'chromium' ,
},
},
},
};
export default async function (const page = await browser.newPage ();
try {
await page.goto ('https://example.com' );
const title = await page.title ();
console .log (`Page title: ${title} ` );
await page.click ('button[data-testid="submit"]' );
await page.waitForSelector ('.success-message' );
} finally {
await page.close ();
}
}
Install browser support: k6 install chromium
WebSocket Testing import ws from 'k6/ws' ;
import { check } from 'k6' ;
export default function (const url = 'wss://echo.websocket.org' ;
ws.connect (url, {}, function (socket ) {
socket.on ('open' , () => {
console .log ('WebSocket connected' );
socket.send ('Hello WebSocket' );
});
socket.on ('message' , (data ) => {
console .log (`Received: ${data} ` );
check (data, {
'echo received' : (d ) => d.includes ('Hello' ),
});
});
socket.on ('close' , () => {
console .log ('WebSocket closed' );
});
socket.setInterval (function (send ('ping' );
}, 1000 );
socket.setTimeout (function (close ();
}, 5000 );
});
}
Data Handling
CSV Data Source import http from 'k6/http' ;
import { check } from 'k6' ;
import { SharedArray } from 'k6/data' ;
const users = new SharedArray ('users' , function (return open ('./users.csv' ).split ('\n' ).slice (1 ).map (line =>const [email, password] = line.split (',' );
return { email, password };
});
});
export default function (const user = users[__VU % users.length ];
const res = http.post ('https://api.example.com/login' ,
JSON .stringify ({ email : user.email , password : user.password })
);
check (res, { 'login successful' : (r ) => r.status === 200 });
}
JSON Data Source import http from 'k6/http' ;
import { check } from 'k6' ;
import { SharedArray } from 'k6/data' ;
const products = new SharedArray ('products' , function (return JSON .parse (open ('./products.json' ));
});
export default function (const product = products[Math .floor (Math .random () * products.length )];
const res = http.get (`https://api.example.com/products/${product.id} ` );
check (res, { 'product found' : (r ) => r.status === 200 });
}
Thresholds & SLA
Basic Thresholds export const options = {
vus : 50 ,
duration : '2m' ,
thresholds : {
http_req_duration : ['p(95)<500' , 'p(99)<1000' ],
http_req_failed : ['rate<0.01' ],
http_reqs : ['rate>100' ],
},
};
Advanced Thresholds export const options = {
thresholds : {
http_req_duration : [
'p(90)<300' ,
'p(95)<500' ,
'p(99)<1000' ,
'avg<200' ,
],
my_custom_metric : ['avg<100' ],
'http_req_duration{method:GET}' : ['p(95)<300' ],
},
};
Custom Metrics
Counters import http from 'k6/http' ;
import { Counter , Trend , Rate , Gauge } from 'k6/metrics' ;
const myCounter = new Counter ('api_calls_total' );
const responseTime = new Trend ('response_time' );
const errorRate = new Rate ('error_rate' );
const activeUsers = new Gauge ('active_users' );
export default function (const res = http.get ('https://api.example.com/data' );
myCounter.add (1 );
responseTime.add (res.timings .duration );
errorRate.add (res.status !== 200 );
activeUsers.add (__VU);
const taggedRes = http.get ('https://api.example.com/users' , {
tags : { endpoint : 'users' , env : 'prod' },
});
}
CI/CD Integration
GitHub Actions
name: Load Tests
on:
push:
branches: [main ]
schedule:
- cron: '0 2 * * *'
jobs:
load-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup k6
uses: grafana/k6-action@v0.2.0
- name: Run load test
env:
API_TOKEN: ${{ secrets.API_TOKEN }}
run: k6 run --out json=results.json load-test.js
- name: Upload results
uses: actions/upload-artifact@v4
with:
name: k6-results
path: results.json
- name: Check thresholds
if: failure()
run: |
echo "Load test failed thresholds!"
exit 1
GitLab CI
load_test:
image: grafana/k6:latest
script:
- k6 run load-test.js
artifacts:
when: always
paths:
- results.json
reports:
junit: results.xml
Results Analysis
Built-in Reports
k6 run load-test.js
k6 run --out json=results.json load-test.js
k6 run --out influxdb=http://localhost:8086/k6 load-test.js
k6 run --out prometheus=localhost:9090/k6 load-test.js
k6 run --out cloud load-test.js
Interpreting Results Metric Description Good Warning Bad http_req_duration (p95) 95% response time < 300ms 300-500ms > 500ms http_req_failed Error rate < 0.1% 0.1-1% > 1% http_reqs Requests/sec Meeting target Near limit At limit vus Virtual users Stable Gradual increase Unexpected spike
Examples
Example 1: Basic API Load Test import http from 'k6/http' ;
import { check, sleep } from 'k6' ;
export const options = {
vus : 50 ,
duration : '2m' ,
thresholds : {
http_req_duration : ['p(95)<500' ],
http_req_failed : ['rate<0.01' ],
},
};
export default function (const res = http.get ('https://api.example.com/users' );
check (res, {
'status is 200' : (r ) => r.status === 200 ,
'response time < 500ms' : (r ) => r.timings .duration < 500 ,
});
sleep (1 );
}
Example 2: Test with Authentication and Data Parameterization import http from 'k6/http' ;
import { check } from 'k6' ;
import { SharedArray } from 'k6/data' ;
const users = new SharedArray ('users' , function (return JSON .parse (open ('./users.json' ));
});
export default function (const user = users[__VU % users.length ];
const loginRes = http.post ('https://api.example.com/login' ,
JSON .stringify ({ email : user.email , password : user.password })
);
const token = loginRes.json ('access_token' );
const headers = { 'Authorization' : `Bearer ${token} ` };
const res = http.get ('https://api.example.com/profile' , { headers });
check (res, { 'profile loaded' : (r ) => r.status === 200 });
}
Best Practices
Start with smoke test : Verify test works with 1-5 VUs before scaling upUse realistic data : Parameterize with real user data and behaviorsSet meaningful thresholds : Match your SLA and business requirementsWarm up systems : Include ramp-up time in stagesMonitor external dependencies : Track not just your APIs but downstream servicesUse tags : Tag requests for granular analysis (tags: { endpoint: 'users' })Keep tests focused : One test file per scenario for clarity
Common Pitfalls
Problem: Tests pass locally but fail in CI
Solution: Ensure CI environment has similar resources and network conditions
Problem: Inconsistent results between runs
Solution: Check for external dependencies, random data, or test data pollution
Problem: k6 runs out of memory
Solution: Use SharedArray for large data, reduce VUs, or use --max-memory flag
Problem: Thresholds too strict
Solution: Start with relaxed thresholds, tighten based on historical data
Related Skills
@performance-engineer - For broader performance optimization@api-testing-observability-api-mock - For API mocking during testing@application-performance-performance-optimization - For performance optimization
Additional Resources 