Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/BEKO2210/Firstbrain --skill k6-load-testingLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Métiers associés SOC
Basé sur la classification professionnelle 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. type skill created 2026-02-27T00:00:00.000Z domain software-development category testing risk safe source community tags ["skill","software-development","testing","load"]
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
Connections
Domain: [[Software Entwicklung]]Kategorie: [[Testing & Qualitaet]]Navigation: [[Skills Uebersicht]], [[Home]] 