এই পর্বে যা শিখবেন
- k6 script-এর গঠন: init,
setup,default,teardown, আর VU ও iteration-এর সম্পর্ক - Check আর threshold-এর পার্থক্য, আর একটি non-functional requirement-কে threshold বানিয়ে CI-র gate করা
- ছয়টি executor চেনা, আর কাজ অনুযায়ী ঠিক executor বাছাই
- Closed আর open model-এর পার্থক্য, আর arrival-rate executor কেন coordinated omission এড়ায়
- Group, tag, JSON output আর end-of-test summary পড়া; k6-কে Locust, JMeter আর Gatling-এর পাশে বিচার করা
১ · k6 কী, আর এই পর্বের lab
ঈদের আগের রাতে বাজারঘরে ভিড়ের কথা ভাবুন। হাজারো মানুষ একসাথে “তেল” খুঁজছেন, পণ্যের পাতা খুলছেন, কার্টে যোগ করছেন। একজন tester হাতে ক্লিক করে এই ভিড় বানাতে পারেন না। দরকার এমন একটি যন্ত্র, যা অনেক নকল ব্যবহারকারী বানিয়ে একই সাথে app-এ পাঠাবে, প্রতিটি উত্তরের সময় মাপবে, আর শেষে বলবে লক্ষ্য পূরণ হলো কি না। এই যন্ত্রকে বলে load generator, আর পুরো কাজটি একটি load test.
পর্ব ৪৬-এ (Performance testing — load, stress, soak, spike আর percentile) ধারণাগুলো এসেছে: percentile, গড় কেন ভুল বোঝায়, open আর closed workload. পর্ব ৪৭-এ একই কাজ Python-এর Locust দিয়ে। এই পর্বে আরেকটি জনপ্রিয় tool, k6. এখানে ধারণাগুলো আবার শেখানো হবে না; দেখা হবে k6 সেগুলো কীভাবে প্রকাশ করে, আর একটি বাস্তব প্রশ্নের উত্তর: বাজারঘর কি NFR-2 পূরণ করে?
k6-এ test লেখা হয় JavaScript-এ, কিন্তু সেটি Node.js বা browser-এ চলে না। k6 নিজেই একটি Go program, যার ভেতরে Go-তে লেখা একটি JavaScript engine আছে। প্রতিটি virtual user (VU) সেই engine-এর একটি আলাদা ছোট জগৎ, যা আপনার script বারবার চালায়। ফলে একটি সাধারণ ল্যাপটপেও শত শত VU চালানো যায়; বিনিময়ে npm-এর প্যাকেজ সরাসরি চলে না, আর k6-এর নিজের module (k6/http, k6) দিয়েই কাজ সারতে হয়।
k6 শুরু হয় সুইডেনের একটি load testing প্রতিষ্ঠান Load Impact-এ; GitHub-এ এর repository খোলা হয় ২০১৬ সালে, আর ২০১৭ সালের দিকে এটি open source হিসেবে প্রকাশ পায়। ২০২১ সালে k6 Grafana Labs-এর অংশ হয়। বহু বছর 0.x সংস্করণে চলার পর ২০২৫ সালের মে মাসে k6 v1.0 আসে, আর ২০২৬ সালের মে মাসে v2.0, যেখানে বহু পুরোনো command আর option বাদ দেওয়া হয় (release notes অনুযায়ী)। এই পর্বের সব run সর্বশেষ সংস্করণ v2.4.0-এ।
Lab: কী চালানো হলো, কোথায়
এই পর্বের সব সত্যিকারের run একটি Windows ল্যাপটপে, আলাদা scratch ফোল্ডারে। k6 v2.4.0-এর অফিসিয়াল standalone Windows zip সেই ফোল্ডারে নামানো হয়েছিল, কিছু install করা হয়নি, আর কাজ শেষে মুছে ফেলা হয়েছে। লাইসেন্স AGPL-3.0 (GitHub repository-র লাইসেন্স তথ্য অনুযায়ী)। বাজারঘরের app (MIT) নিজের কপি থেকে চলেছে শুধু 127.0.0.1:8823-এ, test mode-এ, নিজের database ফাইলে, একটি worker process-এ। কোনো বাইরের host বা website-এ একটিও request যায়নি; load test শুধু নিজের যন্ত্রে, নিজের app-এ চালানো বৈধ আর নিরাপদ।
cd ~/bazarghar-qa/k6
export K6_NO_USAGE_REPORT=true # usage statistics off, before the first run
export GOMAXPROCS=2 # k6 may use at most 2 CPU threads
./k6 version
./k6 run --no-usage-report -q nfr2.jsk6.exe v2.4.0 (commit/dd9395906d, go1.26.11, windows/amd64)
দুটি সতর্কতা। এক, k6 ডিফল্টভাবে বেনামি ব্যবহারের পরিসংখ্যান (usage report) পাঠায়; প্রথম run-এর আগেই K6_NO_USAGE_REPORT=true বা --no-usage-report দিয়ে এটি বন্ধ রাখা হয়েছে। দুই, app আর load generator এখানে একই ল্যাপটপে চলেছে, আর ল্যাপটপে অন্য কাজও চলছিল। তাই সংখ্যাগুলো আকার আর তুলনা দেখায় (ঠিক বনাম ধীর, closed বনাম open), production-এর ক্ষমতা নয়। VU-র সংখ্যা সর্বোচ্চ ১০০, আর প্রতিটি run ৩০ সেকেন্ডের।
২ · একটি k6 script-এর গঠন — VU, iteration আর জীবনচক্র
একটি রেস্তোরাঁর কথা ভাবুন। প্রতিটি টেবিলে একজন অতিথি বসেন, খাবার অর্ডার দেন, খান, কিছুক্ষণ গল্প করেন, তারপর আবার অর্ডার দেন। টেবিলের সংখ্যা স্থির; অতিথিরা নিজের ছন্দে ঘুরে ঘুরে একই কাজ করেন। k6-এ টেবিল হলো VU, আর একটি পুরো “অর্ডার-খাওয়া-গল্প” চক্র হলো একটি iteration. গল্পের সময়টিকে বলে think time: একজন আসল ক্রেতা এক পাতা থেকে পরের পাতায় যাওয়ার আগে যে সময় নেন।
নিচের script-টি এই পর্বের প্রধান test. NFR-2 (পর্ব ১৫) লেখা হয়েছিল রিভিউ জমার জন্য: “৫০ জন একসাথে থাকলেও ৯৫% সাড়া ২ সেকেন্ডের মধ্যে।” বাজারঘরের দল একই মাপকাঠি পণ্য খোঁজার পথেও বসিয়েছে; এই মডিউলে সেটিই যাচাই হবে। একজন ক্রেতার পথ: “oil” খোঁজা, চালের রিভিউ দেখা, নিজের কার্ট দেখা, তারপর এক সেকেন্ড ভাবা। k6 script লেখা হয় সাধারণ JavaScript-এ; ভাষাটি নতুন হলে JavaScript প্রোগ্রামিং কোর্স-এর শুরুর দিকটা দেখে নিতে পারেন।
import http from 'k6/http';
import { check, group, sleep } from 'k6';
const BASE = __ENV.BASE_URL || 'http://127.0.0.1:8823';
export const options = {
scenarios: {
nfr2: { executor: 'constant-vus', vus: 50, duration: '30s' },
},
thresholds: {
'http_req_duration{name:search}': ['p(95)<2000'], // NFR-2
http_req_failed: ['rate<0.01'],
checks: ['rate>0.99'],
},
};
export function setup() { // runs once, before the VUs start
const r = http.post(`${BASE}/api/auth/login`,
JSON.stringify({ email: 'mitu@bazarghar.test', password: __ENV.MITU_PASSWORD }),
{ headers: { 'Content-Type': 'application/json' } });
return { token: r.json('access_token') };
}
export default function (data) { // one iteration = one user journey
group('browse', () => {
const s = http.get(`${BASE}/api/products?q=oil`, { tags: { name: 'search' } });
check(s, { 'search 200': (r) => r.status === 200,
'oil found': (r) => r.json('total') === 2 });
http.get(`${BASE}/api/products/1/reviews`, { tags: { name: 'reviews' } });
});
const auth = { headers: { Authorization: `Bearer ${data.token}` }, tags: { name: 'cart' } };
check(http.get(`${BASE}/api/cart`, auth), { 'cart 200': (r) => r.status === 200 });
sleep(1); // think time
}Script-টি চারটি ভাগে পড়ুন। Init অংশ (function-গুলোর বাইরের কোড): import, ঠিকানা আর options. এখানে network request করা যায় না; k6 এই অংশ প্রতিটি VU-র জন্য একবার করে চালায়। setup() পুরো test-এ একবার চলে, VU-রা কাজ শুরুর আগে: এখানে মিতু একবার লগইন করে, আর ফেরত দেওয়া { token } প্রতিটি VU-র default(data)-তে পৌঁছায়। এভাবে লগইনের খরচ মাপার মধ্যে ঢোকে না, আর একটি bearer token সবাই ভাগ করে। default function হলো একটি iteration. teardown(data) (এখানে নেই) সবশেষে একবার চলে, যেমন test data পরিষ্কারের জন্য। পাসওয়ার্ড script-এ লেখা নেই; আসে __ENV.MITU_PASSWORD থেকে, যা চালানোর সময় environment variable হিসেবে দেওয়া হয় (এটি app-এর নকল demo পাসওয়ার্ড)।
একটি k6 run-এর জীবনচক্র
init → setup → VUs repeat default() → teardown → summary → thresholds → exit code
তিনটি জিনিস script-এ আছে, যেগুলো পরে বারবার আসবে। group('browse', …) কয়েকটি request-কে একটি নামের নিচে রাখে, যাতে ফলের সারাংশে সেই অংশের সময় আলাদা দেখা যায়; একে বলে group. tags: { name: 'search' } প্রতিটি request-এর গায়ে একটি লেবেল বসায়; এই tag দিয়েই পরে শুধু search-এর সময় আলাদা করা যাবে। আর check(…) একটি উত্তর যাচাই করে; এর কাজ পরের অংশে।
৩ · Check বনাম threshold — NFR-2 থেকে CI-র gate
বাজারের পাইকারি আড়তে দুই ধরনের যাচাই চলে। প্রতিটি বস্তা নামানোর সময় একজন খুলে দেখেন চাল ভেজা কি না, আর খাতায় দাগ দেন: ভালো, খারাপ। এটি প্রতিটি জিনিসের যাচাই। দিনের শেষে মালিক খাতা দেখে সিদ্ধান্ত নেন: খারাপ বস্তা ১%-এর বেশি হলে পুরো চালান ফেরত। এটি পুরো চালানের রায়। k6-এ প্রথমটি check, দ্বিতীয়টি threshold.
| বিষয় | Check | Threshold |
|---|---|---|
| কী যাচাই করে | একটি উত্তর: status 200? JSON-এ total 2? | পুরো run-এর একটি metric: p95, ব্যর্থতার হার |
| কোথায় লেখা | default-এর ভেতরে, check(res, {…}) | options.thresholds-এ |
| ব্যর্থ হলে | শুধু গোনা হয় (checks metric); run চলতে থাকে | run শেষে ✗, আর exit code 99 |
| CI-তে প্রভাব | নিজে থেকে কিছু নয় | ০ নয় বলে CI job লাল |
| প্রশ্নের ধরন | “উত্তরটি ঠিক?” (functional) | “লক্ষ্য পূরণ হলো?” (non-functional) |
দুটিকে যুক্ত করার প্রচলিত কৌশল script-এ আছে: checks: ['rate>0.99']. এখানে checks হলো k6-এর তৈরি একটি rate metric, যা সব check-এর পাস করার অনুপাত রাখে; তার ওপর threshold বসালে ১%-এর বেশি check ব্যর্থ হলেও run ব্যর্থ হবে। NFR-2 নিজে হলো একটি লাইন: 'http_req_duration{name:search}': ['p(95)<2000']. বাম দিকের অংশ বলে কোন metric (http_req_duration, প্রতিটি request-এর মোট সময়), আর বাঁকা বন্ধনীর ভেতরে কোন tag-এর অংশ (শুধু search); ডান দিকে শর্ত, ৯৫তম percentile ২০০০ ms-এর কম। একটি non-functional requirement এভাবে যন্ত্রে পড়ার মতো একটি quality gate হয়ে গেল।
প্রথম সত্যিকারের run, ঠিক app-এ (কোনো seeded bug নেই), ৫০ VU, ৩০ সেকেন্ড। -q দেওয়ায় চলার সময়ের progress লাইন নেই, শুধু শেষের সারাংশ (জায়গা বাঁচাতে কয়েকটি সারি বাদ):
█ THRESHOLDS
checks
✓ 'rate>0.99' rate=100.00%
http_req_duration{name:search}
✓ 'p(95)<2000' p(95)=49.73ms
http_req_failed
✓ 'rate<0.01' rate=0.00%
█ TOTAL RESULTS
checks_succeeded...: 100.00% 4446 out of 4446
✓ search 200
✓ oil found
✓ cart 200
HTTP
http_req_duration..............: avg=9.8ms min=0s med=3.5ms max=153.76ms p(90)=25.07ms p(95)=41.18ms
{ name:search }..............: avg=10.76ms min=0s med=2.96ms max=153.76ms p(90)=27.4ms p(95)=49.73ms
http_req_failed................: 0.00% 0 out of 4447
http_reqs......................: 4447 143.32588/s
EXECUTION
iteration_duration.............: avg=1.02s min=1s med=1.01s max=1.22s p(90)=1.06s p(95)=1.12s
iterations.....................: 1482 47.76455/s
vus_max........................: 50 min=50 max=50
…
exit=0
এই end-of-test summary ওপর থেকে পড়ুন। THRESHOLDS: তিনটিই ✓, তাই exit code 0 (শেষ লাইনটি আমাদের shell-এর echo). checks: ১৪৮২টি iteration × ৩টি check = ৪৪৪৬, সবগুলো পাস। HTTP: প্রতিটি iteration-এ তিনটি request, সাথে setup-এর একটি লগইন, মোট ৪৪৪৭। http_req_duration একটি trend metric, তাই তার avg, med, p(90), p(95) দেখায়; আর tag দেওয়া ছিল বলে নিচে { name:search }-এর আলাদা সারি। EXECUTION: একটি iteration গড়ে ১.০২ s, যার এক সেকেন্ড think time; তাই প্রতি সেকেন্ডে প্রায় ৪৭.৮টি iteration. এটি পর্ব ৪৬-এর Little's law-এর সাথে মেলে: ৫০ জন VU ÷ ১.০২ s ≈ ৪৯ iteration প্রতি সেকেন্ডে, শুরু-শেষের ক্ষয় বাদে কাছাকাছি। (min=0s দেখে অবাক হবেন না; খুব ছোট সময়ের মাপে Windows-এর ঘড়ির সূক্ষ্মতার সীমা থাকতে পারে।)
Error-এর সংজ্ঞা: http_req_failed ডিফল্টভাবে ২০০–৩৯৯-এর বাইরের status-কে ব্যর্থ ধরে। কিন্তু 409 বা 404 কখনো প্রত্যাশিতও হতে পারে (যেমন একই রিভিউ দ্বিতীয়বার জমা দিলে বাজারঘর 409 দেয়)। তখন সেই request-এর জন্য প্রত্যাশিত status আলাদা করে বলে দিতে হয়, নইলে ভুল “error rate” দেখাবে। Error-এর সংজ্ঞা নিজে একটি requirement-এর প্রশ্ন।
৪ · Seeded bug চালু — threshold ভাঙে, exit code 99
বাজারঘরের app-এ একটি ইচ্ছা করে বসানো performance bug আছে, slow_search: চালু করলে /api/products-এর প্রতিটি request ১৫০০ ms ঘুমায়, যেমন একটি index হারানো query বা ধীর বাইরের service করত। app আবার চালানো হলো --bugs slow_search দিয়ে; script-এর একটি অক্ষরও বদলায়নি। একটি একক request-এর সময় curl দিয়ে আগে দেখে নেওয়া হলো: প্রায় ১.৫০ s. তারপর একই ৫০ VU (কয়েকটি সারি বাদ):
█ THRESHOLDS
checks
✓ 'rate>0.99' rate=100.00%
http_req_duration{name:search}
✗ 'p(95)<2000' p(95)=3.65s
http_req_failed
✓ 'rate<0.01' rate=0.00%
█ TOTAL RESULTS
checks_succeeded...: 100.00% 1620 out of 1620
HTTP
http_req_duration..............: avg=625.47ms min=1.48ms med=41.79ms max=4.13s p(90)=1.55s p(95)=1.86s
{ name:search }..............: avg=1.76s min=1.5s med=1.53s max=4.13s p(90)=2.61s p(95)=3.65s
http_reqs......................: 1621 51.694905/s
EXECUTION
iteration_duration.............: avg=2.87s min=2.54s med=2.6s max=5.23s p(90)=4.71s p(95)=4.75s
iterations.....................: 540 17.221005/s
…
time="…" level=error msg="thresholds on metrics 'http_req_duration{name:search}' have been crossed"
exit=99
NFR-2 ভেঙেছে: search-এর p95 ৩.৬৫ s, আর exit code 99. CI-তে এই সংখ্যা ০ নয় বলে job লাল হবে, কেউ রিপোর্ট না পড়লেও। এবার তিনটি সূক্ষ্ম জিনিস লক্ষ করুন, যা এই পর্বের মূল শিক্ষা।
- সব check সবুজ। ১৬২০টির ১৬২০টি পাস: প্রতিটি উত্তর ঠিক ছিল, status 200, “oil”-এ ২টি পণ্য। ধীর কিন্তু সঠিক উত্তর check ধরতে পারে না; সময়ের রায় দেয় threshold.
- Tag ছাড়া ভুল সিদ্ধান্ত। সব request মিলিয়ে
http_req_duration-এর p95 ১.৮৬ s, অর্থাৎ ২ সেকেন্ডের নিচে! দ্রুত reviews আর cart request-এর ভিড়ে ধীর search ঢাকা পড়ে। Threshold-টি যদি tag ছাড়া লেখা হতো, run সবুজ হতো। প্রতিটি পথের জন্য আলাদা tag আর আলাদা threshold রাখুন। - p95 কেন ১.৫ s নয়, ৩.৬৫ s? প্রতিটি search-এ ঘুম ১.৫ s, তবু p95 প্রায় দ্বিগুণের বেশি। কারণ app-এর ভেতরের ক্ষমতা সীমিত: এই app ধীর search চালায় একটি thread pool-এ, যার ডিফল্ট আকার, ব্যবহৃত library-র (AnyIO) নথি অনুযায়ী, ৪০টি thread.
constant-vus৫০ জন VU-কে একই মুহূর্তে ছেড়ে দেয়, ফলে প্রথম ঢেউয়ে ৫০টি search একসাথে আসে; ৪০টি চলে, বাকি ১০টি সারিতে দাঁড়িয়ে আরও ১.৫ s অপেক্ষা করে। VU-রা একসাথে শুরু করেছিল বলে পরের ঢেউগুলোও অনেকটা একসাথে আসে। Queue-তে দাঁড়ানোর এই সময়ই tail latency. পর্ব ৪৬-এর একটানা (think time ছাড়া) ৫০ জনের run-এও ঠিক এই কারণে ফল দুই ভাগে ভাগ হয়েছিল: প্রায় ১.৫ s আর প্রায় ২.৯ s.
শেষ কথাটি যাচাই করা যায়। একই ধীর app-এ একই journey, শুধু executor বদলে ramping-vus: প্রথম ১০ সেকেন্ডে VU ০ থেকে ধীরে ধীরে ৫০-এ ওঠে, তারপর ২০ সেকেন্ড ৫০-এ থাকে। সত্যিকারের ফল (সংক্ষেপে):
http_req_duration{name:search}
✓ 'p(95)<2000' p(95)=1.5s
…
{ name:search }..............: avg=1.5s min=1.5s med=1.5s max=1.51s p(90)=1.5s p(95)=1.5s
iterations.....................: 521 16.013434/s
exit=0
একই bug, একই ৫০ জন, কিন্তু এবার NFR-2 পাস! VU-রা ছড়িয়ে আসায় একসাথে ৪০টির বেশি search কখনো জমেনি, তাই কেউ সারিতে দাঁড়ায়নি। এই ফলাফল দুটি অস্বস্তিকর প্রশ্ন তোলে। এক, “৫০ জন একসাথে” কথাটির মানে কী: একই মিলিসেকেন্ডে ৫০ জন, না ৫০ জন সাইটে আছেন যাঁরা নিজের ছন্দে চলছেন? Requirement যতক্ষণ না বলে, test-এর ফল নির্ভর করে executor বাছাইয়ের ওপর। দুই, search আগে ৫০ ms-এ উত্তর দিত, এখন ১৫০০ ms-এ, তবু gate সবুজ। Threshold শুধু বলে সীমা পার হলো কি না; আগের তুলনায় ৩০ গুণ ধীর হওয়া ধরতে লাগে baseline-এর সাথে তুলনা, যা পর্ব ৫০-এর (SLO-ভিত্তিক test আর capacity planning) বিষয়।
Threshold-এর হিসাব নিজে করে দেখুন
k6 থেকে প্রতিটি মাপ আলাদা করে বের করা যায়: --out json=points.json দিলে প্রতিটি request-এর সময় এক লাইনের JSON হিসেবে ফাইলে লেখা হয় (এই ধরনকে বলে NDJSON). সত্যিকারের একটি লাইন, পরের অংশের open-model run-টি একই সেটিংসে আরেকবার --out json দিয়ে চালিয়ে (এই দ্বিতীয় run-এ ৮৩০টি search শেষ, ৭০টি dropped, p95 ৩.৩১ s):
{"metric":"http_req_duration","type":"Point","data":{"time":"2026-11-16T18:52:38.236611+06:00","value":1532.7106,"tags":{"expected_response":"true","group":"","method":"GET","name":"search","proto":"HTTP/1.1","scenario":"open","status":"200","url":"search"}}}
এই দ্বিতীয় run-এর ৮৩০টি search-এর মাপ থেকে সময়ের ক্রমে প্রতি ৪১তম মাপ নিয়ে ২০টি সংখ্যা নিচের ব্লকে বসানো আছে। ব্লকটি একটি ছোট threshold বিচারক: শর্তের লেখা পড়ে, k6-এর মতো করে percentile হিসাব করে, আর শেষে exit code বলে। “চালান” চাপুন:
// 20 real search latencies (ms) from a k6 --out json run: open model,
// 30 req/s for 30 s, slow_search on; every 41st point, in time order
const ms = [1533, 1504, 1540, 1708, 1711, 1848, 2048, 2183, 2154, 2292,
2524, 2467, 2536, 2710, 3000, 2506, 2980, 2617, 3491, 3016];
function pct(values, p) { // linear interpolation, like k6
const v = [...values].sort((a, b) => a - b);
const i = (p / 100) * (v.length - 1);
const lo = Math.floor(i), hi = Math.ceil(i);
return v[lo] + (v[hi] - v[lo]) * (i - lo);
}
const STAT = {
avg: (v) => v.reduce((a, b) => a + b, 0) / v.length,
med: (v) => pct(v, 50),
max: (v) => Math.max(...v),
};
function evaluate(rule, values) { // "p(95)<2000" -> true / false
const m = rule.match(/^(\w+|p\([\d.]+\))\s*(<=|<|>=|>)\s*([\d.]+)$/);
const [, stat, op, lim] = m;
const limit = Number(lim);
const pm = stat.match(/^p\(([\d.]+)\)$/);
const got = pm ? pct(values, Number(pm[1])) : STAT[stat](values);
const ok = { "<": got < limit, "<=": got <= limit,
">": got > limit, ">=": got >= limit }[op];
console.log(`${rule.padEnd(11)} got=${got.toFixed(1).padStart(7)} ${ok ? "PASS" : "FAIL"}`);
return ok;
}
const results = ["avg<2500", "med<2500", "p(95)<2000"].map((r) => evaluate(r, ms));
console.log("avg of first 10:", STAT.avg(ms.slice(0, 10)), " last 10:", STAT.avg(ms.slice(10)));
console.log("exit code:", results.every(Boolean) ? 0 : 99);আসল আউটপুট:
avg<2500 got= 2318.4 PASS
med<2500 got= 2379.5 PASS
p(95)<2000 got= 3039.8 FAIL
avg of first 10: 1852.1 last 10: 2784.7
exit code: 99
গড় (২৩১৮.৪ ms) আর median (২৩৭৯.৫ ms) দেখে যে দল সীমা ২৫০০ ধরত, তারা সবুজ দেখত; p95 (৩০৩৯.৮ ms) দেখাচ্ছে ধীরতম ৫% কত খারাপ। শেষের আগের লাইনটি আরও একটি গল্প বলে: প্রথম ১০টি মাপের গড় ১৮৫২.১ ms, শেষ ১০টির ২৭৮৪.৭ ms; run চলার সাথে সাথে সময় বাড়ছে, অর্থাৎ queue লম্বা হচ্ছে (§৬-এ এর কারণ)। ২০টি নমুনার p95 পুরো run-এর p95 (৩.৩১ s) থেকে কিছুটা কম, কারণ নমুনা ছোট। একই interpolation-এর নিয়ম পুরো ৮৩০টি মাপে আলাদা script-এ চালিয়ে মান হুবহু k6-এর সারাংশের সাথে মিলেছে (৩৩০৯.৩৮২২১৫ ms). নিজে একটি শর্ত বদলে দেখুন, যেমন "p(50)<2500" বা "max<4000".
1pts = search latencies2v = sort(pts)3i = 0.95 * (n - 1)4p = v[18] + (v[19]-v[18])*0.055p < 2000 ?6exit(any failed ? 99 : 0)
| n | |
| i | |
| v[18], v[19] | |
| p95 | |
| রায় |
- মাপ জমা। Run চলার সময় k6 প্রতিটি search-এর
http_req_durationজমায়। এখানে নমুনা ২০টি, সময়ের ক্রমে; প্রথমটি ১৫৩৩ ms, শেষটি ৩০১৬ ms. - সাজানো। Percentile-এর জন্য মানগুলো ছোট থেকে বড় সাজাতে হয়। সবচেয়ে বড় দুটি, ঘর ১৮ আর ১৯-এ (০ থেকে গুনে), ৩০১৬ আর ৩৪৯১.
- অবস্থান। ৯৫তম percentile-এর অবস্থান i = ০.৯৫ × (২০ − ১) = ১৮.০৫. এটি কোনো পূর্ণ ঘর নয়; ঘর ১৮ থেকে ৫% পথ এগিয়ে।
- Interpolation. দুই ঘরের মাঝের রেখা ধরে মান: ৩০১৬ + (৩৪৯১ − ৩০১৬) × ০.০৫ = ৩০৩৯.৭৫ ms. অন্য tool “nearest rank” নিয়মে সরাসরি একটি ঘর নিতে পারে; ছোট নমুনায় এই পার্থক্য চোখে পড়ে।
- শর্ত। ৩০৩৯.৭৫ < ২০০০ মিথ্যা, তাই এই threshold ✗. সারাংশে লেখা হয় “thresholds … have been crossed”.
- Exit code. একটিও threshold ভাঙলে k6 শেষে exit code 99 দেয়; সব ঠিক থাকলে 0. CI কোনো লেখা পড়ে না, শুধু এই সংখ্যা দেখে job লাল বা সবুজ করে।
৫ · Scenario আর executor — চাপের ছন্দ কে ঠিক করে
Script-এর default function বলে একজন ব্যবহারকারী কী করেন; options.scenarios বলে কতজন, কোন ছন্দে, কতক্ষণ। একটি scenario-র কেন্দ্রে থাকে একটি executor, যে VU আর iteration-এর সময়সূচি ঠিক করে। একটি test-এ একাধিক scenario একসাথে চলতে পারে, যেমন ৪০ জন ব্রাউজ করছেন আর প্রতি মিনিটে ১০টি অর্ডার আসছে, প্রতিটি নিজের executor আর নিজের function নিয়ে (exec option). k6 v2-তে ছয়টি executor (আগের সংস্করণের externally-controlled v2.0-তে বাদ গেছে):
| Executor | আপনি স্থির রাখেন | Model | সাধারণ ব্যবহার |
|---|---|---|---|
shared-iterations | মোট iteration, সব VU ভাগ করে | — | smoke test, data তৈরি |
per-vu-iterations | প্রতি VU-তে নির্দিষ্ট iteration | — | প্রতি ব্যবহারকারী একবার একটি কাজ |
constant-vus | VU-র সংখ্যা, একটি সময় ধরে | closed | “৫০ জন সাইটে আছেন” |
ramping-vus | VU-র সংখ্যা, ধাপে ধাপে (stages) | closed | ধীরে ওঠা, stress, soak |
constant-arrival-rate | প্রতি সময়ে নতুন iteration-এর হার | open | “প্রতি সেকেন্ডে ৩০টি search আসে” |
ramping-arrival-rate | হার, ধাপে ধাপে | open | spike, ক্ষমতার সীমা খোঁজা |
- প্রশ্ন
কী স্থির?মানুষ, হার, না সংখ্যা - মানুষ
constant-vusclosed - মানুষ, ধাপে
ramping-vusclosed - হার
constant-arrival-rateopen - হার, ধাপে
ramping-arrival-rateopen - সংখ্যা
shared-iterationssmoke
"৫০ জন সাইটে আছেন" → মানুষ স্থির "প্রতি সেকেন্ডে ৩০টি search" → হার স্থির "১০০টি অর্ডার তৈরি করো" → সংখ্যা স্থির
nfr2: { executor: 'constant-vus',
vus: 50, duration: '30s' }
// ৫০ জন একসাথে শুরু করেন
nfr2: { executor: 'ramping-vus', startVUs: 0,
stages: [{ duration: '10s', target: 50 },
{ duration: '20s', target: 50 }] }
open: { executor: 'constant-arrival-rate',
rate: 30, timeUnit: '1s', duration: '30s',
preAllocatedVUs: 30, maxVUs: 100 }
spike: { executor: 'ramping-arrival-rate',
startRate: 5, timeUnit: '1s', maxVUs: 100,
stages: [{ duration: '20s', target: 5 },
{ duration: '5s', target: 40 },
{ duration: '20s', target: 5 }] }
smoke: { executor: 'shared-iterations',
vus: 1, iterations: 5 }
// প্রতিটি পরিবর্তনে দ্রুত একটি নিশ্চিতকরণ
- প্রথম প্রশ্ন। Requirement বা পরিকল্পনা কী স্থির রাখতে বলে: সাইটে থাকা মানুষের সংখ্যা, নতুন কাজ আসার হার, না মোট কাজের সংখ্যা? এই উত্তরই executor-এর পরিবার ঠিক করে, বাকিটা খুঁটিনাটি।
- মানুষ স্থির:
constant-vus. ৫০ জন VU পুরো ৩০ সেকেন্ড ঘুরে ঘুরে কাজ করেন। প্রত্যেকে আগের উত্তর পেলে তবেই পরের request পাঠান, তাই এটি closed model. §৪-এর প্রথম দুটি run এটি দিয়ে। - মানুষ, ধাপে ধাপে:
ramping-vus.stages-এর প্রতিটি ধাপ বলে কত সময়ে কতজনে পৌঁছাতে হবে। ধীরে ওঠা warm-up দেয় আর একসাথে শুরু হওয়ার ঢেউ এড়ায়; §৪-এর তৃতীয় run এভাবেই পাস করেছিল। Stress আর soak test-ও সাধারণত এই ধাঁচে। - হার স্থির:
constant-arrival-rate. প্রতিtimeUnit-এrateটি নতুন iteration শুরু হয়, app ধীর হলেও। VU আগে থেকে তৈরি থাকে (preAllocatedVUs), দরকারেmaxVUsপর্যন্ত বাড়ে। এটি open model; §৬-এর মূল run. - হার, ধাপে ধাপে:
ramping-arrival-rate. এখানে ৫ থেকে হঠাৎ ৪০ আগমন প্রতি সেকেন্ডে, তারপর আবার ৫: একটি spike test-এর আকার। হারের ধাপ ধীরে বাড়িয়ে কোথায় latency হঠাৎ লাফ দেয় (knee), তাও খোঁজা যায়। এই উদাহরণটি এই lab-এ চালানো হয়নি। - সংখ্যা স্থির:
shared-iterations. একজন VU পাঁচবার পুরো পথ ঘুরে আসে, তারপর শেষ। প্রতিটি পরিবর্তনের পরে দ্রুত দেখা “script আর app দুটোই চলছে কি”, অর্থাৎ k6-এর ভাষায় একটি smoke test. এটিও এখানে উদাহরণ মাত্র।
দুটি ব্যবহারিক খুঁটিনাটি। প্রথমত, arrival-rate executor-এ VU-র সংখ্যা আপনি ঠিক করেন না, প্রয়োজন ঠিক করে। কতজন লাগবে, তা আবার Little's law: হার × একটি iteration-এর সময়। ৩০টি আগমন প্রতি সেকেন্ডে আর প্রতিটি ১.৫ s হলে একসাথে প্রায় ৪৫টি VU ব্যস্ত থাকবে; app আরও ধীর হলে আরও বেশি। maxVUs-এও না কুলালে k6 নতুন iteration শুরু করতে পারে না, আর সেগুলো গোনে dropped_iterations নামে। দ্বিতীয়ত, closed model-এ think time (sleep) রাখা জরুরি; open model-এ সাধারণত দরকার নেই, কারণ আগমনের ঘড়িই ছন্দ ঠিক করে।
৬ · Closed বনাম open — একই ধীর app, দুই ভিন্ন গল্প
বাসস্ট্যান্ডের টিকিট কাউন্টারের কথা ভাবুন। একটি ধরন: ৩০ জন নিয়মিত যাত্রী, প্রত্যেকে টিকিট পেয়ে এক মিনিট পরে আবার লাইনে দাঁড়ান। কাউন্টার ধীর হলে তাঁরাও কম আসেন, কারণ আগের টিকিট হাতে না পেয়ে কেউ ফিরতে পারেন না। এটি closed workload. আরেক ধরন: রাস্তা থেকে প্রতি মিনিটে নতুন যাত্রী আসেন, কাউন্টার ধীর কি না তাঁরা জানেন না। কাউন্টার ধীর হলে লাইন শুধু লম্বা হয়। এটি open workload. ইন্টারনেটের দোকানে নতুন ক্রেতা দ্বিতীয় ধরনের মতো আসেন: কেউ জানেন না app-এর ভেতরে কত ভিড়।
পরীক্ষাটি এই: একই script, শুধু “oil” search, দুই model-এ, ঠিক আর ধীর app-এ, প্রতিবার ৩০ সেকেন্ড। Closed: constant-vus, ৩০ VU, প্রতি iteration-এ ১ s think time; ঠিক app-এ এটি প্রায় ৩০টি search প্রতি সেকেন্ডে দেয়। Open: constant-arrival-rate, প্রতি সেকেন্ডে ৩০টি নতুন iteration, maxVUs: 100. তাই দুই model-এর উদ্দেশ্য একই চাপ। চারটি সত্যিকারের run:
| Run | request | হার/s | search p95 | dropped | NFR-2 |
|---|---|---|---|---|---|
| ঠিক app, closed | 900 | 29.6 | 25.44 ms | — | ✓ exit 0 |
| ঠিক app, open | 901 | 30.0 | 3.54 ms | 0 | ✓ exit 0 |
| slow_search, closed | 360 | 11.9 | 1.54 s | — | ✓ exit 0 |
| slow_search, open | 834 | 25.4 | 3.26 s | 67 | ✗ exit 99 |
ধীর app-এর দুটি সারি পাশাপাশি পড়ুন। Closed model বলছে: p95 ১.৫৪ s, NFR-2 পাস, exit 0. কিন্তু সেই run-এ মোট request মাত্র ৩৬০টি, প্রতি সেকেন্ডে ১১.৯টি, যেখানে উদ্দেশ্য ছিল ৩০টি। App ধীর হতেই VU-রা অপেক্ষায় আটকে গেল, আর load generator নিজেই চাপ কমিয়ে দিল। Open model আসল ছবি দেখাল: আগমন থামেনি, app কুলাতে পারেনি, p95 ৩.২৬ s, ৬৭টি iteration শুরুই হতে পারেনি, আর VU-র সংখ্যা উঠেছিল ৮৯-এ। Closed model-এর এই “চাপ কমিয়ে ভালো ফল দেখানো”-কে বলে coordinated omission: tool আর server যেন একসাথে ধীরতম মুহূর্তগুলো লুকিয়ে ফেলে। ধারণাটি Gil Tene-র ২০১০-এর দশকের বক্তৃতার মাধ্যমে ব্যাপক পরিচিতি পায় বলে উল্লেখ করা হয়; বিস্তারিত ব্যাখ্যা আছে ক্লাউড কম্পিউটিং ও DevOps কোর্সের পর্ব ৬৮-এ আর সিস্টেম ডিজাইন কোর্সের পর্ব ০৪-এ।
1bug off: target 30 req/s2bug on: +1.5 s per search3closed: 30 VUs, think 1 s4open: 30 arrivals per s
| closed হার | |
| closed p95 | |
| open হার | |
| open p95 |
- Bug বন্ধ। ঠিক app-এ দুই model প্রায় একই চাপ দেয়: closed ২৯.৬, open ৩০.০ search প্রতি সেকেন্ডে। Search কয়েক ms-এ শেষ, তাই think time-ই closed model-এর ছন্দ ঠিক করে। দুটিতেই NFR-2 পাস।
- Bug চালু। এখন প্রতিটি search ১.৫ s. App-এর ভেতরের ৪০টি thread একসাথে সর্বোচ্চ ৪০টি search চালাতে পারে, তাই ক্ষমতা মোটামুটি ৪০ ÷ ১.৫ ≈ ২৬.৭টি search প্রতি সেকেন্ডে। এর বেশি এলে queue জমবে।
- Closed: চাপ নিজে থেকে কমে। প্রতিটি VU-র চক্র এখন ১.৫ s অপেক্ষা + ১ s think = ২.৫ s. ৩০ জন VU মিলে ৩০ ÷ ২.৫ = ১২টি search প্রতি সেকেন্ডে, যা ক্ষমতার অনেক নিচে। আসল run: ১১.৯/s.
- Closed: বিভ্রান্তিকর সবুজ। ক্ষমতার নিচে বলে কেউ সারিতে দাঁড়ায় না; p95 ১.৫৪ s, NFR-2 পাস, exit 0. অথচ বাস্তবের ৩০ জন ক্রেতা প্রতি সেকেন্ডে আসতেই থাকতেন। Load generator ধীর app-এর সাথে তাল মিলিয়ে চাপ অর্ধেকেরও কম করে দিয়েছে।
- Open: queue জমে। আগমনের ঘড়ি থামে না, প্রতি সেকেন্ডে ৩০টি; ক্ষমতা ২৬.৭টি। প্রতি সেকেন্ডে প্রায় ৩টি করে বাড়তি search সারিতে জমে, অপেক্ষা বাড়ে, আর ব্যস্ত VU-র সংখ্যা বেড়ে ৮৯-এ ওঠে (Little's law: হার × সময়)।
- Open: সৎ লাল। ৮৩৪টি search শেষ, ৬৭টি শুরুই হয়নি (
dropped_iterations), p95 ৩.২৬ s. NFR-2 ✗, exit 99. ধীরতাটি open model-ই পুরো দেখাল, কারণ এখানে চাপ app-এর গতির ওপর নির্ভর করে না।
সংখ্যাগুলো কি কাকতালীয়? যাচাইয়ের একটি উপায় হলো একটি ছোট মডেল বানানো, যেখানে app মানে ৪০টি thread আর প্রতিটি search ঠিক ১.৫ s, আর দেখা মডেল একই আকারের ফল দেয় কি না। নিচের ব্লকটি এই পাতাতেই Python-এ চলে (Pyodide; প্রথমবার নামতে কয়েক সেকেন্ড লাগে):
import heapq
THREADS, SERVICE, DURATION = 40, 1.5, 30.0 # app model: 40 threads, 1.5 s per search
def serve(t, free): # FIFO: the thread that frees up first takes it
start = max(t, heapq.heappop(free))
heapq.heappush(free, start + SERVICE)
return start + SERVICE - t # latency the client sees
def p95(xs): # k6-style linear interpolation
xs = sorted(xs); i = 0.95 * (len(xs) - 1); lo = int(i)
return xs[lo] + (xs[min(lo + 1, len(xs) - 1)] - xs[lo]) * (i - lo)
def closed(vus=30, think=1.0): # a VU sends again only after reply + think
free, lat, users = [0.0] * THREADS, [], [(0.0, u) for u in range(vus)]
while users:
t, u = heapq.heappop(users)
if t < DURATION:
lat.append(serve(t, free))
heapq.heappush(users, (t + lat[-1] + think, u))
return lat, 0
def open_model(rate=30, max_vus=100): # arrivals follow a clock, not replies
free, lat, busy, dropped = [0.0] * THREADS, [], [], 0
for k in range(int(rate * DURATION)):
t = k / rate
while busy and busy[0] <= t: heapq.heappop(busy) # VU back in the pool
if len(busy) >= max_vus: dropped += 1; continue
lat.append(serve(t, free)); heapq.heappush(busy, t + lat[-1])
return lat, dropped
for name, (lat, dropped) in [("closed 30 VUs", closed()), ("open 30/s", open_model())]:
print(f"{name:14} sent={len(lat):4} rate={len(lat)/DURATION:5.1f}/s "
f"p95={p95(lat):.2f}s max={max(lat):.2f}s dropped={dropped}")আসল আউটপুট:
closed 30 VUs sent= 360 rate= 12.0/s p95=1.50s max=1.50s dropped=0
open 30/s sent= 860 rate= 28.7/s p95=3.80s max=3.80s dropped=40
Closed model-এর মডেল আর আসল run প্রায় হুবহু: দুটোতেই ৩৬০টি request, ১২/s, p95 প্রায় ১.৫ s. Open model-এ আকার একই, সংখ্যা কাছাকাছি কিন্তু হুবহু নয়: মডেলে ৮৬০টি পাঠানো, p95 ৩.৮০ s, ৪০টি dropped; আসল run-এ ৮৩৪টি শেষ, p95 ৩.২৬ s, ৬৭টি dropped. পার্থক্যের কারণ মডেলের সরলতা: আসল app-এ thread pool ছাড়াও network, JSON আর k6-এর নিজের হিসাবের সময় আছে, আর মডেল “পাঠানো” গোনে, k6 গোনে “শেষ হওয়া”। মডেলের কাজ সংখ্যা মেলানো নয়, কারণ বোঝা: closed()-এ পরের request-এর সময় নির্ভর করে lat[-1]-এর ওপর, অর্থাৎ app ধীর হলে চাপ কমে; open_model()-এ সময় আসে শুধু k / rate থেকে। SERVICE ০.০০৫ করে চালালে দুই model আবার প্রায় একই চাপ দেখাবে; নিজে করে দেখুন।
তাহলে কি সবসময় open model? না। কিছু system সত্যিই closed: একটি call center-এর ২০ জন এজেন্ট, বা একটি অফিসের নির্দিষ্ট কর্মীরা, যাঁরা আগের কাজ শেষ না করে পরেরটি ধরেন না। প্রশ্ন হলো আসল ব্যবহারকারী কীভাবে আসেন। খোলা ইন্টারনেটের দোকানে নতুন ক্রেতার আগমন open-এর কাছাকাছি; সেখানে শুধু closed model দিয়ে NFR যাচাই করলে ধীরতার মুহূর্তে চাপ কম মাপা হবে।
৭ · Output, CI আর কয়েকটি ফাঁদ
Summary, JSON আর একটি উল্টো true
শেষের সারাংশ মানুষের পড়ার জন্য; যন্ত্রের জন্য দুটি পথ। --out json=… প্রতিটি মাপ আলাদা লাইনে লেখে (§৪-এ দেখেছেন), যা পরে নিজের script-এ বিশ্লেষণ করা যায়, বা বড় দলে একটি time-series database-এ পাঠানো যায়। --summary-export=summary.json শুধু শেষের সারাংশ JSON-এ লেখে। প্রথম run-এর export থেকে সত্যিকারের অংশ:
"http_req_failed": {
"passes": 0,
"fails": 4447,
"thresholds": {
"rate<0.01": false
},
"value": 0
…
"max": 153.7689,
"thresholds": {
"p(95)<2000": false
}
দুটি জিনিস প্রথমবার দেখলে উল্টো মনে হয়। এক, "p(95)<2000": false এই run-এ, যেখানে threshold পাস করেছিল; আর slow_search-এর open run-এর export-এ একই চাবির মান ছিল true. অর্থাৎ এই export-এ true মানে “সীমা পার হয়েছে”, পাস নয়। দুই, http_req_failed-এ "passes": 0 আর "fails": 4447, যেখানে একটিও request ব্যর্থ হয়নি। এটি একটি rate metric, যার “pass” মানে মানটি সত্য, অর্থাৎ request ব্যর্থ। কোনো রিপোর্ট বা dashboard এই ফাইল পড়লে প্রথমে একটি জানা ভালো আর একটি জানা খারাপ run দিয়ে অর্থ মিলিয়ে নিন। k6-এর নথিতে handleSummary() নামে একটি function-ও আছে, যা দিয়ে সারাংশ নিজের মতো করে লেখা যায়, এবং নতুন একটি machine-readable summary-র option-ও (--new-machine-readable-summary); কোনটি ব্যবহার করবেন, সংস্করণের নথি দেখে ঠিক করুন।
CI-তে একটি performance gate
Threshold-এর exit code-ই CI-র ভাষা। একটি CI job-এর ভেতরে মূল লাইনগুলো দেখতে এমন (উদাহরণ; CI-র pipeline আর stage-এর পূর্ণ নকশা পর্ব ৬৪-এ, CI-তে test pipeline):
# start the app under test on the CI runner, then:
export K6_NO_USAGE_REPORT=true
./k6 run --no-usage-report -q --summary-export=k6-summary.json k6/nfr2.js
# exit 0 → job passes
# exit 99 → a threshold was crossed → job fails, summary kept as an artifactএই গেট বসানোর আগে তিনটি প্রশ্ন ভাবুন। কোথায় চালাবেন: CI runner-এর ক্ষমতা ভাগ করা আর ওঠানামা করে, তাই সেখানে মাপা সময় একটি নির্দিষ্ট পরিবেশের তুলনামূলক সংখ্যা, production-এর নয়। কত বড়: প্রতিটি পরিবর্তনে ছোট, কয়েক সেকেন্ডের smoke-আকারের load; বড় load test রাতে বা release-এর আগে। Noise: একই commit দুবার চালালে p95 কিছুটা আলাদা হবেই; সীমার খুব কাছাকাছি threshold একটি flaky gate হয়ে ওঠে, যা পর্ব ৪০-এর flaky test-এর মতোই বিশ্বাস নষ্ট করে।
আরও কয়েকটি বাস্তব ফাঁদ
| ফাঁদ | লক্ষণ | প্রতিকার |
|---|---|---|
| Check দিয়ে gate ভাবা | অনেক check ব্যর্থ, তবু exit 0 | checks: ['rate>0.99']-এর মতো threshold |
| Tag ছাড়া এক threshold | দ্রুত request ধীরকে ঢেকে দেয় (১.৮৬ s বনাম ৩.৬৫ s) | প্রতিটি গুরুত্বপূর্ণ পথে name tag আর আলাদা threshold |
| প্রতিটি id-র আলাদা URL | /api/products/1, /2 … হাজারো আলাদা সারি | একই name tag দিয়ে এক দলে রাখা |
| প্রতিটি iteration-এ লগইন | লগইনের খরচ সব পথের সময়ে মিশে যায় | লগইন setup()-এ, বা আলাদা scenario হিসেবে মাপা |
| সবাই একসাথে শুরু | শুরুর ঢেউয়ে বাড়তি tail latency | ramping-vus বা arrival-rate; ইচ্ছা করে ঢেউ চাইলে spike test বলুন |
| Generator নিজেই ক্লান্ত | Load generator-এর CPU পূর্ণ, মাপা সময় বেড়ে যায় | Generator-এর CPU আর memory দেখা; দরকারে আলাদা যন্ত্র |
শেষ একটি ক্ষমতার কথা: k6-এর একটি browser module (k6/browser) আছে, যা আসল browser চালিয়ে পাতা খোলার সময় মাপতে পারে, protocol-স্তরের request-এর পাশাপাশি। এখানে এটি চালানো হয়নি; ব্রাউজারের দিক থেকে performance মাপা পর্ব ৫১-এর (Frontend performance — Lighthouse আর Core Web Vitals) বিষয়।
৮ · k6 বনাম Locust, JMeter আর Gatling
Load testing tool অনেক, আর “সেরা কোনটি” প্রশ্নের উত্তর দলের দক্ষতা আর কাজের ধরনের ওপর নির্ভর করে। নিচের তুলনা সাধারণ বৈশিষ্ট্যের; প্রতিটির নথি আর লাইসেন্স নিজে একবার দেখে নিন।
| Tool | Test লেখা হয় | লাইসেন্স | যা ভালো | যা খেয়াল রাখবেন |
|---|---|---|---|---|
| k6 | JavaScript, একটি Go binary | AGPL-3.0 | একক ফাইল, threshold → exit code, executor-এ open model | npm চলে না; AGPL-এর শর্ত বোঝা |
| Locust (পর্ব ৪৭) | Python class | MIT | Python দল, নমনীয় আচরণ, web UI | মূল ধারণা ব্যবহারকারী-ভিত্তিক; হারের জন্য বাড়তি নকশা |
| Apache JMeter | GUI-তে test plan (XML ফাইল) | Apache-2.0 | বহু protocol, পুরোনো ও বিস্তৃত plugin | XML-এর test review করা কঠিন; GUI মোড load-এর জন্য নয় |
| Gatling | কোডে DSL (Java, Kotlin, Scala…) | Apache-2.0 (community) | দক্ষ engine, open ও closed injection, রিপোর্ট | JVM-এর জগৎ; বাণিজ্যিক সংস্করণ আলাদা |
এই কোর্সের ভাগটি এমন: Python জানা দল আর জটিল ব্যবহারকারীর আচরণের জন্য Locust স্বাভাবিক; একটি নির্দিষ্ট NFR-কে CI-র gate বানাতে আর open model সহজে পেতে k6 সুবিধাজনক। দুটির যেকোনোটিতেই মূল প্রশ্ন একই থাকে: workload কতটা বাস্তব, কোন percentile কোন পথে, আর ফল কতটা পুনরাবৃত্তিযোগ্য।
আরও গভীরে: একটি load generator নিজেও একটি পরিমাপ যন্ত্র, আর তার নিজস্ব ভুল আছে। Closed-loop tool-এ coordinated omission ছাড়াও generator-এর CPU পূর্ণ হলে সে নিজেই দেরিতে request পাঠায় আর দেরিতে উত্তর পড়ে, ফলে মাপা latency-তে generator-এর ক্লান্তি মিশে যায়। এজন্য বড় test-এ generator-এর resource আলাদা করে দেখা হয়, আর arrival-rate executor-এর dropped_iterations-কে একটি সতর্কসংকেত ধরা হয়: সংখ্যাটি শূন্য না হলে পরিকল্পিত চাপ আসলে দেওয়া হয়নি। পরিসংখ্যানের দিক থেকে, একটি ৩০ সেকেন্ডের run-এর p95 নিজেও একটি অনুমান; একাধিক run-এর ফল আর তার বিস্তার দেখা ছাড়া দুটি build-এর ছোট পার্থক্যকে আসল উন্নতি বা অবনতি বলা ঝুঁকিপূর্ণ।
পরীক্ষা ও ইন্টারভিউতে:
- k6-এ check আর threshold-এর পার্থক্য? Check একটি উত্তর যাচাই করে গোনে, run থামায় না; threshold পুরো run-এর metric-এর ওপর রায় দেয়, ভাঙলে exit code 99.
- VU আর iteration কী? VU একজন নকল ব্যবহারকারী, যে
defaultfunction বারবার চালায়; প্রতিটি চালানো একটি iteration. - constant-vus আর constant-arrival-rate-এর পার্থক্য? প্রথমটি ব্যবহারকারীর সংখ্যা স্থির রাখে (closed), দ্বিতীয়টি নতুন iteration-এর হার (open); app ধীর হলে প্রথমটিতে চাপ কমে, দ্বিতীয়টিতে queue বাড়ে।
dropped_iterationsকী বোঝায়? Arrival-rate executor নির্ধারিত সময়ে iteration শুরু করতে পারেনি, কারণmaxVUs-এর সব VU ব্যস্ত; পরিকল্পিত চাপ পুরো দেওয়া হয়নি।- “p95 < 2 s” কীভাবে CI gate হয়?
thresholds-এ'http_req_duration{name:search}': ['p(95)<2000']; ভাঙলে k6-এর exit code ০ নয়, তাই job ব্যর্থ।
৯ · AI-এর যুগে — AI-এর লেখা k6 script যাচাই
AI সহকারী এক মিনিটে পরিপাটি k6 script লিখে দেয়। দেখতে নির্ভুল, কিন্তু এই কাজে কিছু ভুল বারবার আসে: শুধু সুখী পথ (happy path), কোনো threshold নেই, আর check দিয়েই “test ব্যর্থ হবে” ভাবা; সব request মিলিয়ে একটি threshold, যা ধীর পথকে ঢেকে দেয়; কল্পিত option বা ভুল বানান (একটি executor বা threshold-এর এমন রূপ, যা নথিতে নেই), বা পুরোনো সংস্করণের বাদ পড়া flag; প্রতিটি request-এর পরে অন্ধ sleep, অথচ open model-এ এর দরকার নেই; কোনো বাস্তব কারণ ছাড়া ৫০০ বা ১০০০ VU; script-এ আসল দেখতে পাসওয়ার্ড বা token; আর সবচেয়ে বিপজ্জনক, লক্ষ্য হিসেবে একটি বাইরের বা production ঠিকানা। শেষে প্রায়ই একটি দাবি: “এই test NFR পূরণ নিশ্চিত করবে”, অথচ কিছুই চালানো হয়নি।
AI-কে কাজ দিন ছোট করে, সীমা স্পষ্ট করে:
AI-এর লেখা load test হাতে পেলে — চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।
প্র ০১k6-এর script JavaScript-এ, অথচ এটি Node.js-এ চলে না; চলে Go-তে লেখা নিজস্ব engine-এ। এই নকশার পেছনের যুক্তি কী, আর এর দাম কী?
একটি load generator-এর প্রধান কাজ হলো কম resource-এ অনেক নকল ব্যবহারকারী চালানো, আর প্রতিটির সময় নির্ভুলভাবে মাপা। পুরোনো অনেক tool প্রতিটি ব্যবহারকারীর জন্য একটি OS thread ব্যবহার করত; thread ভারী, তাই কয়েকশো ব্যবহারকারীতেই যন্ত্র হাঁপিয়ে উঠত। Go ভাষার goroutine খুব হালকা, আর একটি Go program হাজারো goroutine চালাতে পারে। k6-এর নির্মাতারা তাই engine লিখলেন Go-তে, আর প্রতিটি VU-কে দিলেন একটি আলাদা, ছোট JavaScript runtime (প্রথমে goja নামের একটি Go-তে লেখা JavaScript engine, পরে তার থেকে আসা Sobek, বলে প্রকল্পের নথিতে উল্লেখ আছে)।
JavaScript বেছে নেওয়ার কারণও ব্যবহারিক: web-এর সাথে যুক্ত প্রায় সব দলে কেউ না কেউ JavaScript পড়তে পারেন, আর ছোট script-এ এর গঠন সহজ। Test কোড হিসেবে থাকায় এটি repository-তে রাখা, review করা আর diff দেখা যায়, যা GUI-তে বানানো XML test plan-এ কঠিন। একটি মাত্র binary ফাইল হওয়ায় CI-তে নামানো আর চালানোও সহজ; এই পর্বের lab-এ zip খুলেই কাজ শুরু হয়েছে।
দামও আছে। Node.js নয় বলে npm-এর প্যাকেজ সরাসরি চলে না; Node-এর built-in module (যেমন fs) নেই, আর কিছু আধুনিক JavaScript বৈশিষ্ট্য সংস্করণভেদে সীমিত থাকতে পারে। বাড়তি ক্ষমতা আসে k6-এর নিজস্ব module বা Go-তে লেখা extension থেকে, যার জন্য নিজস্ব build লাগে। আর একজন JavaScript developer প্রায়ই ধরে নেন async/await বা browser-এর API এখানে একইভাবে আছে, যা সবসময় সত্য নয়।
Tester-এর জন্য শিক্ষা হলো: tool-এর ভাষা দেখে তার runtime অনুমান করবেন না। “JavaScript” লেখা থাকলেও কোন engine, কোন module, কোন সীমা, তা নথিতে দেখে নিন; বিশেষ করে AI যখন Node-এর অভ্যাসে লেখা কোড দেয়। আর load generator-এর দক্ষতা কেবল সুবিধা নয়, মাপের সঠিকতার শর্ত: generator হাঁপিয়ে উঠলে তার দেরি মাপা latency-তে মিশে যায়।
মূল উপলব্ধি: k6 পরিচিত ভাষা আর দক্ষ engine মিলিয়েছে; বিনিময়ে Node-এর জগৎ ছেড়েছে, তাই script লেখার আগে runtime-এর সীমা জেনে নিন।
প্র ০২k6-এর লাইসেন্স AGPL-3.0. একটি দল যদি k6 দিয়ে নিজের app test করে, তাদের কি নিজের test script বা app প্রকাশ করতে হবে? Tool বাছাইয়ে লাইসেন্স কেন একটি testing-এর প্রশ্ন?
GNU Affero General Public License v3 (AGPL-3.0) একটি copyleft লাইসেন্স, ২০০৭ সালে Free Software Foundation প্রকাশ করে। GPL-এর মতোই, কেউ program-টি পরিবর্তন করে বিতরণ করলে পরিবর্তিত source-ও একই লাইসেন্সে দিতে হয়। AGPL-এর বাড়তি শর্ত হলো network: কেউ পরিবর্তিত program-কে network-এর ওপর অন্যদের ব্যবহারের জন্য সেবা হিসেবে চালালে, সেই ব্যবহারকারীদেরও source পাওয়ার সুযোগ দিতে হয়। লক্ষ্য ছিল “সেবা হিসেবে চালিয়ে copyleft এড়ানো”-র ফাঁক বন্ধ করা।
একটি দল যখন k6-কে অপরিবর্তিত একটি tool হিসেবে চালিয়ে নিজের app-এ load দেয়, তখন সাধারণ বোঝাপড়া হলো এতে নিজের app বা test script AGPL-এর আওতায় আসে না; script হলো k6-এর input, k6-এর পরিবর্তিত রূপ নয়, আর app তো k6-এর অংশই নয়। প্রশ্ন জটিল হয় যখন কেউ k6-এর source বদলে নিজস্ব সংস্করণ বানায় আর সেটি অন্যদের দেয়, বা সেটিকে বাইরের গ্রাহকদের জন্য সেবা হিসেবে চালায়। এটি আইনি পরামর্শ নয়; প্রতিষ্ঠানের নিয়ম আর আইনজীবীর মত আলাদা হতে পারে।
লাইসেন্স কেন testing-এর প্রশ্ন? কারণ tool বাছাইয়ের সিদ্ধান্ত বহু বছর টেকে। কিছু প্রতিষ্ঠানে AGPL-এর সফটওয়্যারের জন্য আলাদা অনুমোদন লাগে; সেটি না জেনে পুরো performance suite k6-এ বানালে পরে বদলাতে হতে পারে। আবার open-source লাইসেন্স মানে source দেখা যায়, ফলে একটি মাপ নিয়ে সন্দেহ হলে percentile কীভাবে হিসাব হয় তা নিজে পড়ে যাচাই করা যায়, যা এই পর্বে আমরা ফল মিলিয়ে করেছি। Grafana Labs ২০২১ সালে নিজের আরও কয়েকটি প্রধান প্রকল্পও AGPL-3.0-তে নেয় বলে জানা যায়; বাণিজ্যিক open-source প্রতিষ্ঠানগুলোর এই ধরনের লাইসেন্স বদল আজ সাধারণ ঘটনা।
ব্যবহারিক অভ্যাস হলো: প্রতিটি tool-এর লাইসেন্স একবার লিখে রাখা (এই কোর্সে প্রতিটি tool-এর পাশে যেমন লেখা হয়), প্রতিষ্ঠানের নীতির সাথে মিলিয়ে নেওয়া, আর tool পরিবর্তন করার আগে আলাদা করে ভাবা।
মূল উপলব্ধি: অপরিবর্তিত k6 দিয়ে নিজের app test করা আর k6 বদলে বিতরণ করা দুটি আলাদা পরিস্থিতি; লাইসেন্স জানা tool বাছাইয়েরই অংশ।
প্র ০৩Requirement বলে “৫০ জন একসাথে”। এই পর্বের run-এ একই ধীর app একবার পাস করল, একবার ব্যর্থ হলো, শুধু executor বদলে। তাহলে requirement-টি কীভাবে লেখা উচিত ছিল?
“একসাথে ব্যবহারকারী” (concurrent users) শব্দটি performance requirement-এ সবচেয়ে প্রচলিত, আর সম্ভবত সবচেয়ে অস্পষ্ট। এর অন্তত তিনটি অর্থ হতে পারে: একই মুহূর্তে ৫০টি request চলমান; সাইটে ৫০ জন লগইন করা মানুষ, যাঁরা নিজের ছন্দে পড়ছেন আর ক্লিক করছেন; বা প্রতি সেকেন্ডে এত নতুন কাজ, যা গড়ে ৫০ জনের সমান। এই পর্বের সত্যিকারের run দেখিয়েছে পার্থক্য কতটা বড়: constant-vus-এ ৫০ জন একসাথে শুরু করায় p95 ৩.৬৫ s, ব্যর্থ; ramping-vus-এ ধীরে ওঠায় p95 ১.৫ s, পাস। App একই, bug একই।
Little's law এখানে অনুবাদকের কাজ করে: ভেতরে থাকা গড় সংখ্যা = আগমনের হার × প্রতিটির সময়। “৫০ জন সাইটে, প্রত্যেকে প্রতি ২.৫ সেকেন্ডে একটি search করেন” মানে প্রায় ২০টি search প্রতি সেকেন্ডে। এখন requirement-টি যন্ত্রে বসানো যায় এবং যাচাই করা যায়: “পণ্য খোঁজার পথে প্রতি সেকেন্ডে ২০টি আগমন, ৫ মিনিট ধরে, ১ মিনিটের warm-up বাদ দিয়ে, p95 ≤ ২ s, error ১%-এর কম।” এতে আছে পথ, চাপের ধরন, সময়, মাপার নিয়ম আর সীমা।
আরও দুটি প্রশ্ন বাকি থাকে: চূড়ার চাপ কত (ঈদের আগের রাত বা বড় ছাড়ের দিন সাধারণ দিনের কত গুণ), আর আগমন কেমন (সমানভাবে, না ঢেউয়ে)। এগুলোর উত্তর আসে বাস্তব ব্যবহারের তথ্য থেকে, অনুমান থেকে নয়; নতুন app-এ সেই তথ্য না থাকলে অনুমানটি লিখে রাখা আর পরে মিলিয়ে দেখা উচিত। পর্ব ৫০-এ capacity planning-এ এই প্রশ্নগুলো বিস্তারিত আসবে।
Tester-এর ভূমিকা এখানে পর্ব ১৫-এর মতোই: অস্পষ্ট শব্দে থামা আর প্রশ্ন করা। “৫০ জন একসাথে” দেখলে জিজ্ঞেস করুন: কোন পথে, কোন ছন্দে, কতক্ষণ, কোন percentile, কোন পরিবেশে? প্রতিটি উত্তর scenario-র একটি লাইন হয়।
মূল উপলব্ধি: “একসাথে ব্যবহারকারী” একটি অসম্পূর্ণ requirement; পথ, আগমনের হার বা ধরন, সময় আর percentile না বললে test-এর ফল নির্ভর করে tool বাছাইয়ের ওপর।
প্র ০৪Coordinated omission ধরা পড়ার পরও অনেক load test closed model-এ চলে। কেন, আর এই পর্বের ১.৫৪ s বনাম ৩.২৬ s ফল থেকে কী শেখা যায়?
Coordinated omission ধারণাটি ব্যাপক পরিচিতি পায় Gil Tene-র ২০১০-এর দশকের বক্তৃতা আর লেখার মাধ্যমে (তাঁর “How NOT to Measure Latency” বক্তৃতা প্রায়ই উদ্ধৃত হয়)। মূল কথা: একটি মাপার যন্ত্র যদি server-এর উত্তরের অপেক্ষায় পরের request পাঠানো পিছিয়ে দেয়, তাহলে server যখন সবচেয়ে ধীর, ঠিক তখনই মাপ কম নেওয়া হয়। ফলে খারাপ মুহূর্তগুলো পরিসংখ্যান থেকে প্রায় হারিয়ে যায়, আর percentile আসলের চেয়ে ভালো দেখায়।
তবু closed model প্রচলিত, কয়েকটি কারণে। এক, এটি স্বাভাবিক মনে হয়: “৫০ জন ব্যবহারকারী” ভাবা সহজ, “প্রতি সেকেন্ডে ২০টি আগমন” কম সহজ। দুই, অনেক পুরোনো tool আর tutorial এই ধাঁচেই বানানো। তিন, closed model generator-এর জন্য নিরাপদ: VU-র সংখ্যা স্থির, তাই memory কখনো লাফ দেয় না। আর কিছু system সত্যিই closed, যেমন নির্দিষ্ট সংখ্যক কর্মী বা যন্ত্র, যারা আগের কাজ শেষ না করে পরেরটি ধরে না।
এই পর্বের দুটি সংখ্যা সমস্যাটিকে হাতে-কলমে দেখায়। একই ধীর app, একই উদ্দেশ্য (প্রতি সেকেন্ডে প্রায় ৩০টি search). Closed model পাঠাল মাত্র ৩৬০টি request, প্রতি সেকেন্ডে ১১.৯টি, আর বলল p95 ১.৫৪ s, পাস। Open model প্রতি সেকেন্ডে ৩০টি আগমন চালিয়ে গেল, app কুলাতে পারল না, p95 ৩.২৬ s, ৬৭টি iteration শুরুই হলো না। Closed model-এর সংখ্যা মিথ্যা নয়; সেটি একটি অন্য প্রশ্নের সঠিক উত্তর: “৩০ জন ধৈর্যশীল মানুষ, যাঁরা উত্তরের অপেক্ষা করেন, কী দেখবেন?” সমস্যা হয় যখন সেই উত্তরকে “প্রতি সেকেন্ডে ৩০ জন নতুন ক্রেতা কী দেখবেন” প্রশ্নের উত্তর ভাবা হয়।
করণীয়: open system-এ arrival-rate executor ব্যবহার, dropped_iterations শূন্য কি না দেখা, closed model ব্যবহার করলে আসল পাঠানো হার রিপোর্টে লেখা (উদ্দেশ্য নয়), আর latency গোনা পরিকল্পিত পাঠানোর সময় থেকে, যেখানে tool সেটি সমর্থন করে।
মূল উপলব্ধি: Load model নিজেই একটি অনুমান; ধীরতার মুহূর্তে যে model চাপ কমিয়ে দেয়, সে ঠিক সেই মুহূর্তটিই কম মাপে।
প্র ০৫Search ৫০ ms থেকে ১৫০০ ms-এ নেমে গেল, তবু ramping-vus run-এ NFR-2 সবুজ। একটি performance gate কীভাবে নকশা করলে এই ধরনের অবনতি ধরা পড়বে, অথচ gate flaky হবে না?
একটি absolute threshold (p95 < ২০০০ ms) একটি প্রশ্নের উত্তর দেয়: ব্যবহারকারীর কাছে প্রতিশ্রুত সীমা পার হলো কি না। এটি জরুরি, কিন্তু যথেষ্ট নয়। এই পর্বের ramping-vus run-এ search ৩০ গুণ ধীর হয়েও সীমার নিচে ছিল; পরের মাসে আরেকটি ছোট ধীরতা যোগ হলেই সীমা পার হবে, আর তখন কোন পরিবর্তন দায়ী তা খুঁজতে হবে অনেক commit-এর মধ্যে। তাই অনেক দল দুই স্তরের gate রাখে।
প্রথম স্তর, SLO বা NFR-এর absolute gate: সীমা ভাঙলে release থামে। দ্বিতীয় স্তর, regression gate: আগের ভালো build-এর (baseline) তুলনায় একটি সহনশীলতার বেশি খারাপ হলে সতর্কতা বা থামা, যেমন “p95 baseline-এর চেয়ে ২৫% বা ১০০ ms-এর বেশি বেড়েছে”। দ্বিতীয়টি এই পর্বের ১৫০০ ms-এর অবনতি সাথে সাথে ধরত।
সমস্যা হলো noise. একই commit দুবার চালালেও p95 বদলায়: যন্ত্রের অন্য কাজ, cache, network, এমনকি একসাথে শুরু হওয়ার ঢেউ (যা এই পর্বে ১.৫ s আর ৩.৬৫ s-এর পার্থক্য তৈরি করেছিল)। খুব আঁটসাঁট regression gate তাই flaky হয়, আর পর্ব ৪০-এ যেমন দেখেছেন, flaky gate মানুষকে লাল উপেক্ষা করতে শেখায়। প্রতিকারগুলো পরিসংখ্যানের: একই পরিবেশে চালানো, warm-up বাদ দেওয়া, একাধিক run নিয়ে median বা বিস্তার দেখা, সহনশীলতা noise-এর মাপের চেয়ে বড় রাখা, আর সন্দেহজনক ফলে স্বয়ংক্রিয়ভাবে আবার চালানো।
আরেকটি নকশার সিদ্ধান্ত: কোন gate কোথায়। প্রতিটি pull request-এ ছোট, দ্রুত একটি load (কয়েক সেকেন্ড, কয়েকজন VU), যা বড় অবনতি ধরে; রাতে বা release-এর আগে পূর্ণ load test, যা NFR যাচাই করে। পর্ব ৫০-এ SLO আর baseline-ভিত্তিক gate হাতে-কলমে বানানো হবে।
মূল উপলব্ধি: Absolute threshold প্রতিশ্রুতি রক্ষা করে, baseline-এর তুলনা অবনতি ধরে; দুটিকেই noise-এর মাপ জেনে সাজাতে হয়, নইলে gate নিজেই flaky হয়।
অনুশীলন
উত্তর দেখার আগে কাগজে নিজে করুন।
-
Spec থেকে scenario আর threshold: বাজারঘরের বড় ছাড়ের দিনের জন্য লিখিত লক্ষ্য: (ক) পণ্য খোঁজা: প্রতি সেকেন্ডে ২০টি আগমন, p95 ≤ ২ s; (খ) অর্ডার দেওয়া: প্রতি মিনিটে ৬০টি অর্ডার, p99 ≤ ৩ s; (গ) পুরো test-এ HTTP error ০.৫%-এর কম; (ঘ) দুই পথ একসাথে, ৫ মিনিট। k6-এর
optionsলিখুন: কোন executor, কোন tag, কোন threshold. VU-র সংখ্যা কীভাবে অনুমান করবেন?দুটি লক্ষ্যই হারে লেখা, তাই দুটিই open model:
export const options = { scenarios: { search: { executor: 'constant-arrival-rate', exec: 'search', rate: 20, timeUnit: '1s', duration: '5m', preAllocatedVUs: 40, maxVUs: 100 }, orders: { executor: 'constant-arrival-rate', exec: 'order', rate: 60, timeUnit: '1m', duration: '5m', preAllocatedVUs: 5, maxVUs: 20 }, }, thresholds: { 'http_req_duration{name:search}': ['p(95)<2000'], 'http_req_duration{name:place-order}': ['p(99)<3000'], http_req_failed: ['rate<0.005'], }, };প্রতিটি scenario নিজের function চালায় (
exec), আর request-এnametag দিয়ে threshold আলাদা। VU-র অনুমান Little's law দিয়ে: search ২০/s × ধরা যাক ১ s = ২০টি ব্যস্ত VU, তাই নিরাপদ শুরু ৪০, সর্বোচ্চ ১০০; অর্ডার ১/s × ধরা যাক ২ s = ২টি, তাই ৫ থেকে ২০। Run শেষেdropped_iterationsশূন্য না হলে VU-র সীমা বা app-এর গতি পরিকল্পিত চাপ দিতে দেয়নি। অর্ডারের test-এ খেয়াল রাখুন: প্রতিটি অর্ডারের জন্য কার্ট, stock আর payment-এর data লাগে, আর payment সবসময় নকল gateway-তে; test mode-এর reset বা আলাদা test data ছাড়া এই scenario বারবার চালানো যায় না। -
এই run-এর ফল পড়ুন: একজন সহকর্মী app চালু হওয়ার আগেই একটি k6 run শুরু করেছিলেন। সত্যিকারের output-এর অংশ (path নিরপেক্ষ করা):
(ক) কোথায় আর কেন থামল? (খ) exit code ১০৭ আর ৯৯-এর পার্থক্য কী? (গ) দুটি threshold-এ ✓ দেখে কেউ বললেন “NFR-2 তো পাস”; কেন ভুল? (ঘ) Script-এ কী যোগ করলে এই ভুল আরও স্পষ্ট বার্তায় ধরা পড়ত?time="…" level=warning msg="Request Failed" error="Post \"http://127.0.0.1:8823/api/auth/login\": dial tcp 127.0.0.1:8823: connectex: No connection could be made because the target machine actively refused it." checks ✓ 'rate>0.99' rate=0.00% http_req_duration{name:search} ✓ 'p(95)<2000' p(95)=0s http_req_failed ✗ 'rate<0.01' rate=100.00% http_req_failed.....: 100.00% 1 out of 1 time="…" level=error msg="GoError: the body is null so we can't transform it to JSON … at setup (file:///…/k6/nfr2_ramp.js:22:25(27))" hint="script exception" exit=107(ক)
setup()-এর লগইন request-এ: app তখনো চালু হয়নি, তাই connection প্রত্যাখ্যাত; উত্তরের body নেই, আরr.json('access_token')null body থেকে JSON পড়তে গিয়ে exception তুলল। Setup ব্যর্থ বলে একটিও VU চলেনি; মোট request মাত্র একটি। (খ) এই run-এ ৯৯ মানে “test চলেছে, কিন্তু threshold ভেঙেছে” (একটি performance রায়), আর ১০৭ এসেছে script-এর exception থেকে, যা পরিবেশ বা script-এর সমস্যা। CI-তে দুটিই লাল, কিন্তু কারণ সম্পূর্ণ আলাদা, তাই রিপোর্টে exit code আলাদা করে দেখানো কাজের। (গ) কোনো search-ই হয়নি, তাইp(95)=0sআরrate=0.00%কোনো আসল মাপ নয়; data ছাড়া threshold-এর ✓-এর কোনো অর্থ নেই। (ঘ)setup()-এ লগইনের status যাচাই করে স্পষ্ট বার্তায় থামানো, যেমনif (r.status !== 200) throw new Error('login failed: ' + r.status), আর CI-তে k6-এর আগে app-এর/api/healthঠিক আছে কি না দেখা। -
এই script আর bug report-এ ভুল খুঁজুন: একজন সহকর্মীর script আর তাঁর রিপোর্ট। অন্তত ছয়টি সমস্যা খুঁজুন।
export const options = { vus: 500, duration: '10m', thresholds: { http_req_duration: ['avg<2000'] }, }; export default function () { const r = http.post('https://shop.example.com/api/auth/login', JSON.stringify({ email: 'mitu@bazarghar.test', password: 'mitu1234' })); const id = Math.floor(Math.random() * 12) + 1; const p = http.get(`https://shop.example.com/api/products/${id}`); check(p, { 'under 2s': (res) => res.timings.duration < 2000 }); }রিপোর্ট: “k6 run সবুজ, তাই NFR-2 (p95 ≤ ২ s, ৫০ জন) পূরণ হয়েছে।”
(১) লক্ষ্য একটি বাইরের ঠিকানা: নিজের অনুমোদিত test পরিবেশ ছাড়া কোথাও load দেওয়া যাবে না। (২) ৫০০ VU, ১০ মিনিট: NFR-2-এর ৫০ জনের সাথে মেলে না, আর যন্ত্রের সীমাও ছাড়ায়। (৩) Threshold গড়ে (
avg), অথচ NFR-2 বলে p95; গড় ধীর লেজকে ঢেকে দেয়। (৪) Threshold সব request মিলিয়ে, tag ছাড়া; লগইনের সময়ও এতে মেশে। (৫) প্রতিটি iteration-এ লগইন: পরিমাপে লগইনের খরচ ঢোকে, আর app-এ হাজারো session জমে; লগইনsetup()-এ রাখুন। (৬) পাসওয়ার্ড script-এ লেখা। (৭) “under 2s” একটি check, gate নয়; ব্যর্থ হলেও exit code বদলায় না। (৮) প্রতিটি পণ্যের id আলাদা URL; একটিnametag দিয়ে এক দলে রাখা উচিত। (৯) Think time নেই, তাই ৫০০ VU আসলে বাস্তবের চেয়ে অনেক বেশি চাপ দেয়। (১০) Random-এর seed বা নির্দিষ্ট তালিকা নেই, তাই দুটি run-এর তুলনা কঠিন। রিপোর্টের ভুল: “run সবুজ” মানে শুধুavg<2000পাস করেছে; NFR-2-এর পথ, percentile বা চাপের মাপ এই test যাচাই করেনি। -
ফল অনুমান করুন: একটি app-এ ২০টি worker thread, প্রতিটি request ঠিক ১ সেকেন্ড নেয়, আর সারি সাজানো আসার ক্রমে। দুটি test, প্রতিটি ৬০ সেকেন্ড: (ক) closed, ২৫ জন VU, প্রতি iteration-এ ১ s think time; (খ) open, প্রতি সেকেন্ডে ২৫টি আগমন। প্রতিটিতে প্রতি সেকেন্ডে কতটি request যাবে, latency কেমন হবে? খোলা (খ)-তে VU-র কোনো সীমা না থাকলে শেষ দিকের request কতক্ষণ অপেক্ষা করবে, আর
maxVUs: 100দিলে কী বদলাবে?ক্ষমতা: ২০ thread ÷ ১ s = প্রতি সেকেন্ডে ২০টি। (ক) Closed: এক চক্র = ১ s উত্তর + ১ s think = ২ s, তাই ২৫ ÷ ২ = ১২.৫টি প্রতি সেকেন্ডে, ক্ষমতার নিচে; latency প্রায় ১ s (শুধু শুরুর মুহূর্তে ২৫ জন একসাথে আসায় ৫ জন একবার ২ s পান)। (খ) Open: চাওয়া ২৫/s, ক্ষমতা ২০/s; প্রতি সেকেন্ডে ৫টি করে সারিতে জমে, ৬০ সেকেন্ডে প্রায় ৩০০টি। সীমাহীন VU-তে শেষ দিকের request প্রায় ৩০০ ÷ ২০ = ১৫ s অপেক্ষা করবে, সাথে নিজের ১ s.
maxVUs: 100দিলে একসাথে ১০০টির বেশি request চলতে পারে না; latency প্রায় ১০০ ÷ ২০ = ৫ s-এ আটকে থাকে, আর বাকি আগমনdropped_iterationsহয়। এই পর্বের ধাঁচের একটি মডেলে (৬০ s) হিসাব: closed ৭৫০টি request, ১২.৫/s, p95 ১.০ s; open সীমাহীন, সর্বোচ্চ latency ১৫.৮ s; openmaxVUs: 100, latency ৫.০ s আর ২২০টি dropped. লক্ষ করুন, VU-র সীমা latency-কে “ভালো” দেখায়, কিন্তু dropped সংখ্যাটি বলে দেয় চাপ পুরো দেওয়া হয়নি।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি k6 run-এর ধাপগুলো ঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Init — প্রতিটি VU-র জন্য import আর options পড়া
- setup() — পুরো test-এ একবার, যেমন লগইন করে token
- VU-রা default() বারবার চালায় — request, check, think time
- teardown() — শেষে একবার
- End-of-test summary আর threshold-এর বিচার
- Exit code — সব ঠিক থাকলে 0, threshold ভাঙলে 99
একটি k6 script-এ check(res, { 'status 200': (r) => r.status === 200 }) আছে, কিন্তু কোনো threshold নেই। Run-এ ৩০% check ব্যর্থ হলো। k6-এর exit code আর CI-র অবস্থা কী হবে?
- exit 99, CI লাল
- run মাঝপথে থামে, exit 1
- exit 0, CI সবুজ
- exit code = ব্যর্থ check-এর সংখ্যা
লক্ষ্য: “app যত ধীরই হোক, প্রতি সেকেন্ডে ঠিক ৩০টি নতুন search আসবে।” k6-এর কোন executor এই চাপ দেয়?
- constant-vus
- constant-arrival-rate
- shared-iterations
- per-vu-iterations
একটি load test-এ ৫টি search-এর সময় (ms): 100, 200, 300, 400, 1000. k6-এর মতো linear interpolation-এ p(95) কত, আর p(95)<900 threshold-এর ফল কী?
- 1000, FAIL
- 400, PASS
- 700, PASS
- 880, PASS
একটি k6 run শেষে লেখা হলো thresholds on metrics 'http_req_duration{name:search}' have been crossed, আর shell-এ exit code 99. এর সবচেয়ে সঠিক অর্থ কোনটি?
- Test চলেছে, কিন্তু search-এর সময়ের একটি threshold ভেঙেছে
- Script-এ একটি syntax error আছে
- App বন্ধ ছিল, তাই কোনো request যায়নি
- একটি check ব্যর্থ হয়েছে, তাই k6 থেমেছে
একটি app হঠাৎ প্রতিটি request-এ ১.৫ s বেশি নিতে শুরু করল। constant-vus (৩০ VU, প্রতি iteration-এ ১ s think time) দিয়ে মাপলে প্রতি সেকেন্ডে পাঠানো request-এর সংখ্যার কী হবে?
- আগের মতোই প্রায় ৩০/s থাকবে
- k6 VU বাড়িয়ে হার ধরে রাখবে
- হার কমে যাবে, কারণ প্রতিটি VU উত্তরের অপেক্ষায় আটকে থাকে
- হার একই থাকবে, বাড়তি request dropped_iterations হবে
একটি constant-arrival-rate run-এর সারাংশে dropped_iterations: 67 দেখা গেল। এর অর্থ কী?
- ৬৭টি request HTTP error পেয়েছে
- ৬৭টি iteration শুরু করা যায়নি, কারণ সব VU ব্যস্ত ছিল
- ৬৭টি check ব্যর্থ হয়েছে
- ৬৭টি request timeout হয়েছে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- k6-এর গঠন: init →
setup()একবার → VU-রাdefault()বারবার (iteration) →teardown()→ summary আর threshold → exit code. - Check গোনে, threshold রায় দেয়: NFR-2 =
'http_req_duration{name:search}': ['p(95)<2000']; ভাঙলে exit 99, CI লাল। সব check সবুজ থেকেও threshold ভাঙতে পারে। - Tag দিয়ে পথ আলাদা করুন: slow_search-এ সব মিলিয়ে p95 ১.৮৬ s (পাস দেখাত), শুধু search-এ ৩.৬৫ s (ব্যর্থ)।
- Executor ফল বদলায়: একই ধীর app-এ closed (৩০ VU) p95 ১.৫৪ s, পাস; open (৩০/s) p95 ৩.২৬ s আর ৬৭টি dropped, ব্যর্থ। একসাথে শুরু বনাম ধীরে ওঠাও ফল বদলায়।
- সংখ্যা সৎভাবে পড়ুন: একই ল্যাপটপে app আর generator, তাই আকার আর তুলনা, ক্ষমতা নয়;
dropped_iterationsশূন্য কি না দেখুন, আর gate-এ noise হিসাবে রাখুন।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৪৯ · Bottleneck খোঁজা — profiling, query আর resourceপরবর্তী পর্বধীরগতির আসল কারণ খোঁজা: profiler, query plan আর index দেখা।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্বপুরো কোর্সের রোডম্যাপ; পরের পর্ব ৪৯ bottleneck খোঁজা।
- পর্ব ১৫ · Requirement আর testabilityNFR-2“দ্রুত” থেকে মাপা লক্ষ্য p95 ≤ ২ s কীভাবে এলো।
- পর্ব ৪০ · Flaky testnoiseঅস্থির ফল, পরিসংখ্যান আর বিশ্বাসযোগ্য gate.
- পর্ব ৪৫ · Automation frameworkCIConfig, secret আর exit code দিয়ে suite সাজানো।
- সিস্টেম ডিজাইন · পর্ব ০৪percentileLatency, throughput, tail latency আর Little-এর সূত্র।
- ক্লাউড কম্পিউটিং ও DevOps · পর্ব ৬৮loadChaos engineering, load test-এর ধরন আর coordinated omission.