সরাসরি পর্বে যান
পর্ব ৪৭ · ৮২-এর মধ্যে · মডিউল ৮

Locust দিয়ে load test — Python-এ ব্যবহারকারীর আচরণ

Load Testing with Locust: Modelling User Behaviour in Python

Taught in Bangla, this lesson writes load as user behaviour in Locust with HttpUser, weighted tasks, wait_time, SequentialTaskSet journeys and catch_response, after a small Python model predicts request counts. A real Locust 2.47.0 headless run of 50 users for 60 seconds on the Bazarghar demo shop on localhost keeps every endpoint's p95 under 61 ms. A seeded slow_search raises search median from 4 to 1500 ms yet still passes NFR-2, and a LoadTestShape step load finds the knee between 60 and 80 users.

এই পর্বে যা শিখবেন

  • Locust-এর user, task, weight, think time আর spawn rate দিয়ে একটি বাস্তব কেনাকাটার workload লেখা
  • লগইন, test data, Idempotency-Key আর catch_response দিয়ে load test-কে সৎ আর পরিষ্কার রাখা
  • Headless run চালিয়ে CSV থেকে প্রতিটি endpoint-এর p95 বের করা আর NFR-2-এর সাথে মেলানো
  • LoadTestShape দিয়ে ধাপে ধাপে load বাড়িয়ে knee খোঁজা, আর stats table সঠিকভাবে পড়া
  • Distributed mode, load generator-এর সীমা আর একই ল্যাপটপে মাপা সংখ্যার সঠিক ব্যাখ্যা বোঝা

১ · Load test-এ “ব্যবহারকারী” লেখা — Locust-এর মূল ভাবনা

ঈদের আগের রাতে একটি কাপড়ের দোকানের কথা ভাবুন। ভিড় মানে শুধু “অনেক মানুষ” নয়। কেউ শুধু ঘুরে দেখছেন, কেউ একটি নির্দিষ্ট জামা খুঁজছেন, কেউ দাম জিজ্ঞেস করছেন, আর অল্প কয়েকজন কাউন্টারে টাকা দিচ্ছেন। প্রত্যেকে একটি কাজের পর একটু থামেন: কাপড় হাতে নিয়ে দেখেন, পাশের জনের সাথে কথা বলেন। দোকানের ক্যাশ কাউন্টার ভেঙে পড়বে কি না, তা নির্ভর করে এই মিশ্রণ আর থামার ওপর, শুধু মানুষের সংখ্যার ওপর নয়।

পর্ব ০৫-এ দেখেছিলেন, performance একটি non-functional গুণ। পর্ব ৪৬-এ load, stress, soak আর spike test-এর পার্থক্য, percentile, workload model আর Little-এর সূত্র শেখানো হয়েছে; এখানে সেগুলো আবার শেখানো হবে না। এই পর্বের কাজ হাতে-কলমে: একটি load test-এ ওই ভিড়কে কোডে লেখা, চালানো, আর ফল পড়া। Tool হলো Locust, একটি open-source load testing tool, লাইসেন্স MIT. প্রকল্পের নথিতে Jonatan Heyman-কে স্রষ্টা হিসেবে উল্লেখ করা হয়; প্রথম প্রকাশ ২০১১ সালের দিকে বলে জানা যায়। নামের পেছনের ছবিটি পঙ্গপালের ঝাঁক: অনেকগুলো ছোট প্রাণী একসাথে একটি লক্ষ্যে ঝাঁপিয়ে পড়ে।

মূল ধারণা

Locust-এ load লেখা হয় সাধারণ Python কোডে, একটি ফাইলে, যার প্রচলিত নাম locustfile. সেখানে আপনি একটি virtual user-এর আচরণ লেখেন: শুরুতে কী করবে (on_start), কোন কাজ কত ঘন ঘন করবে (task weight), আর দুই কাজের মাঝে কতক্ষণ থামবে (think time, Locust-এ wait_time). তারপর বলেন কতজন user চালাবেন, প্রতি সেকেন্ডে কতজন করে যোগ হবে (spawn rate), আর কতক্ষণ। Locust প্রতিটি request-এর response time আর ফল গুনে endpoint-ভিত্তিক হিসাব দেয়।

এত user একটি process-এ চলে কীভাবে? প্রতিটি user একটি আলাদা OS thread নয়, একটি greenlet: gevent library-র হালকা “সবুজ thread”, যারা নিজেরাই পালা করে চলে। একটি user request পাঠিয়ে উত্তরের অপেক্ষায় থাকলে বা think time-এ ঘুমালে অন্য user চলার সুযোগ পায়। তাই একটি সাধারণ ল্যাপটপেও কয়েকশো user চালানো যায়, যতক্ষণ CPU যথেষ্ট থাকে। সীমাটি পরে, ৮ নম্বর অংশে।

  1. SpawnShopper()greenlet
  2. on_startloginএকবার
  3. Task বাছাই6:3:4:1weight
  4. RequestGETসময় মাপা
  5. wait_time1–3 sthink time
  6. Checkout৪ ধাপক্রমে
  7. Stop-t 60sসময় শেষ
runneruser #7
Ramping to 50 users
at a rate of 5.00 per second
→ Shopper() #7 তৈরি, নিজের greenlet
on_start()নিজের অ্যাকাউন্ট
POST /api/auth/login
  load007@bazarghar.test
← 200 access_token
# পরের সব request-এ Bearer token
weightমোট ১৪
browse   6/14 ≈ 43%
product  4/14 ≈ 29%
search   3/14 ≈ 21%
Checkout 1/14 ≈ 7%
এবার উঠল: browse
self.clientstats-এ যায়
GET /api/products
← 200 in 4 ms
stats["GET /api/products"]
  += 1 request, 4 ms
between(1, 3)ঘুম
wait 1.8 s  (এলোমেলো)
# ঘুমের সময় অন্য user চলে
# ঘুম কোনো stats-এ নেই
SequentialTaskSetএকটি যাত্রা
cart → wait → order → wait
→ pay → wait → cancel
interrupt() → Shopper-এ ফেরা
run-time শেষথামা
--run-time limit reached
user থামে, stats ছাপা হয়
CSV আর HTML লেখা হয়
  1. জন্ম। Runner spawn rate মেনে user বানায়, প্রতি সেকেন্ডে ৫ জন। প্রতিটি user আলাদা Python object, নিজের greenlet-এ চলে।
  2. on_start. প্রতিটি user জীবনে একবার লগইন করে, নিজের আলাদা অ্যাকাউন্টে। Token client-এর header-এ বসে যায়।
  3. Task বাছাই। Weight ৬, ৩, ৪ আর ১, মোট ১৪. প্রতিবার Locust এলোমেলোভাবে একটি বাছে; browse-এর সম্ভাবনা ৬/১৪, প্রায় ৪৩%.
  4. Request. self.client-এর প্রতিটি request-এর সময় আর ফল নামসহ stats-এ জমা হয়। এখানে ৪ ms.
  5. Think time. কাজের পর user ১ থেকে ৩ সেকেন্ডের মধ্যে এলোমেলো সময় থামে। এই ঘুম response time-এ গোনা হয় না, কিন্তু ঠিক করে দেয় user কত ঘন ঘন request পাঠাবে।
  6. যাত্রা। ১৪ বারে প্রায় ১ বার user checkout-এর চার ধাপ ক্রমে চালায়। শেষ ধাপে interrupt() তাকে আবার সাধারণ কাজের বাছাইয়ে ফেরায়।
  7. সমাপ্তি। নির্ধারিত সময় শেষ হলে সব user থামে; Locust চূড়ান্ত table ছাপে আর CSV ও HTML রিপোর্ট লেখে।

২ · বাজারঘরের locustfile — user, task, weight আর think time

এই পর্বের সব সত্যিকারের run একটি Windows ডেস্কটপে, আলাদা scratch ফোল্ডারে: Python 3.12, uv দিয়ে বানানো virtual environment, Locust 2.47.0 (MIT). বাজারঘরের app (MIT) নিজের কপি থেকে চলেছে শুধু 127.0.0.1:8822-এ, test mode-এ, নিজের database ফাইলে, একটি uvicorn worker-এ। একই ল্যাপটপে app আর load generator চলেছে; তাই সংখ্যাগুলো আকার আর তুলনা দেখায়, production-এর ক্ষমতা নয়। Load দেওয়া হয়েছে কেবল নিজের app-এ, সর্বোচ্চ ১০০ জন user আর প্রতি run দুই মিনিটের কম; কোনো বাইরের website ছোঁয়া হয়নি। Log-এর host-এর নাম HOST দিয়ে বদলানো, path নিরপেক্ষ।

প্রথমে বাজারঘরের একজন সাধারণ ক্রেতার আচরণ। ধরুন analytics বলছে, বেশিরভাগ মানুষ পণ্যের তালিকা ঘোরেন, কিছু মানুষ নির্দিষ্ট পণ্য খোঁজেন, অনেকে পণ্যের পাতা খোলেন, আর অল্প কয়েকজন কেনেন। Locust-এ এটি এমন দেখায় (পুরো ফাইলের মূল অংশ):

class Shopper(HttpUser):
    wait_time = between(1, 3)                 # think time, seconds
    tasks = {Checkout: 1}

    def on_start(self):                       # each user logs in once
        n = (next(ACCOUNT) - 1) % 100 + 1
        r = self.client.post("/api/auth/login", json={
            "email": f"load{n:03d}@bazarghar.test", "password": "load1234"})
        self.client.headers["Authorization"] = "Bearer " + r.json()["access_token"]

    @task(6)
    def browse(self):
        self.client.get("/api/products")

    @task(3)
    def search(self):
        with self.client.get("/api/products", params={"q": random.choice(WORDS)},
                             name="/api/products?q=", catch_response=True) as r:
            if r.status_code != 200 or r.json()["total"] == 0:
                r.failure("no results")
            elif r.elapsed.total_seconds() > NFR2_S:
                r.failure("slower than NFR-2 (2 s)")

    @task(4)
    def product(self):
        pid = random.choice(IN_STOCK)
        self.client.get(f"/api/products/{pid}", name="/api/products/[id]")

লাইন ধরে পড়ুন। HttpUser মানে এই user HTTP-তে কথা বলে, আর self.client একটি requests-ধাঁচের client, যার প্রতিটি request Locust নিজে মেপে রাখে। @task(6)-এর ৬ হলো weight: সংখ্যা যত বড়, বাছাইয়ের সম্ভাবনা তত বেশি। tasks = {Checkout: 1} আরেকটি “কাজ” যোগ করে, যা আসলে চার ধাপের একটি যাত্রা (পরের অংশে)। wait_time = between(1, 3) প্রতিটি কাজের পর ১ থেকে ৩ সেকেন্ডের এলোমেলো think time; Locust-এ constant, constant_pacing আর constant_throughput-ও আছে। wait_time না লিখলে Locust-এর User-এ ডিফল্ট constant(0), অর্থাৎ কোনো বিরতি নেই; তখন ৫০ জন user মানে ৫০টি অবিরাম চলা loop, যা মানুষের আচরণ নয়।

name= ছোট কিন্তু জরুরি। /api/products/3 আর /api/products/7 আলাদা URL; নাম না দিলে stats-এ প্রতিটি id আলাদা সারি হতো, আর কোনো সারিতেই যথেষ্ট নমুনা থাকত না। name="/api/products/[id]" সবগুলোকে একটি endpoint হিসেবে গোনে, যাতে তার p95 অর্থবহ হয়। Search-এর query string-কেও একই কারণে এক নামে রাখা হয়েছে।

অ্যাকাউন্ট ভাগাভাগির ফাঁদ: বাজারঘরের seed data-য় মাত্র চারজন ক্রেতা। ৫০ জন virtual user যদি চারটি অ্যাকাউন্ট ভাগ করে নেয়, তাহলে একই কার্টে বারোজন একসাথে পণ্য যোগ করবে, আর একজনের অর্ডার আরেকজনের কার্ট খালি করে দেবে; ফলাফল এমন ব্যর্থতা, যা বাস্তবে কখনো ঘটে না। তাই lab-এর নিজের app কপিতে test mode-এর seed-এ ১০০টি load অ্যাকাউন্ট (load001 … load100, নকল পাসওয়ার্ড) যোগ করা হয়েছে, আর প্রতিটি user নিজেরটি নেয়। Load test-এর test data নিজেই একটি নকশার কাজ।

৩ · একটি পূর্ণ যাত্রা — SequentialTaskSet, catch_response আর Idempotency-Key

Browse আর search একেকটি request. কেনাকাটা কিন্তু একটি ক্রম: কার্টে যোগ, অর্ডার, পেমেন্ট। এলোমেলো বাছাইয়ে “পেমেন্ট আগে, অর্ডার পরে” হয়ে যেতে পারে। SequentialTaskSet তার task-গুলো লেখার ক্রমেই চালায়, প্রতিটির পর think time রেখে:

class Checkout(SequentialTaskSet):            # one journey, steps in order
    @task
    def add_to_cart(self):
        pid = random.choice(IN_STOCK)
        self.client.post("/api/cart/items", json={"product_id": pid, "qty": 1})

    @task
    def place_order(self):
        body = {"district": "Dhaka", "address": "বাড়ি ১২, মিরপুর",
                "phone": "01712345678", "payment_method": "cash",
                "delivery_slot": "evening"}
        with self.client.post("/api/orders", json=body,
                              catch_response=True) as r:
            ok = r.status_code == 201
            if not ok:
                r.failure(f"order {r.status_code}")
        if not ok:
            self.interrupt()                  # skip pay and cancel
        self.order_id = r.json()["id"]

    @task
    def pay(self):
        key = str(uuid.uuid4())               # one key per payment attempt
        self.client.post(f"/api/orders/{self.order_id}/pay",
                         headers={"Idempotency-Key": key},
                         name="/api/orders/[id]/pay")

    @task
    def cancel(self):                         # puts the stock back
        self.client.post(f"/api/orders/{self.order_id}/transition",
                         json={"action": "cancel"},
                         name="/api/orders/[id]/transition")
        self.interrupt()                      # back to the Shopper's tasks

এখানে চারটি নকশার সিদ্ধান্ত আছে, প্রতিটির পেছনে কারণ:

  • catch_response: সাধারণভাবে Locust শুধু HTTP status দেখে: ৪xx বা ৫xx হলে failure. catch_response=True দিলে রায় আপনার হাতে: r.success() বা r.failure("কারণ"). Search-এ এটি দুই কাজ করে: ২০০ এলেও ফল শূন্য হলে failure (খালি উত্তর দ্রুত হলেও ভুল), আর একটি request ২ সেকেন্ডের বেশি নিলে failure, যাতে রিপোর্টে ধীর request-এর সংখ্যা আলাদা দেখা যায়।
  • যাত্রা ভাঙলে থামা: অর্ডার ২০১ না দিলে পেমেন্টে যাওয়ার মানে নেই; interrupt() বাকি ধাপ বাদ দেয়। নইলে একটি ব্যর্থতা থেকে আরও দুটি মিথ্যা ব্যর্থতা জন্মাত।
  • Idempotency-Key: প্রতিটি পেমেন্ট চেষ্টায় একটি নতুন key. Load-এর সময় timeout আর retry বাস্তব ঘটনা; একই key-তে retry দ্বিতীয়বার টাকা কাটে না (পর্ব ২৯)। এখানে পেমেন্ট “cash”, তাই নকল gateway-ও ডাকা হয় না।
  • বাতিল দিয়ে পরিষ্কার: প্রতিটি অর্ডার শেষে বাতিল হয়, আর বাজারঘরের নিয়মে বাতিল স্টক ফেরত দেয়। নইলে কয়েক মিনিটের load-এ তেলের ৩০টি বোতল ফুরিয়ে যেত, আর পরের অর্ডারগুলো ৪০৯ insufficient_stock পেত; সেটি app-এর ধীরতা নয়, test data-র ক্ষয়।

আর পুরো test-এর শুরুতে একবার data নতুন করা দরকার। Locust-এর event hook এই কাজের জন্য:

@events.test_start.add_listener
def fresh_data(environment, **kw):            # once per test, not per user
    if not isinstance(environment.runner, WorkerRunner):
        requests.post(environment.host + "/api/test/reset", timeout=30)

test_start একবার চলে, প্রতিটি user-এর জন্য নয়। Distributed mode-এ এটি master আর প্রতিটি worker-এ চলে, তাই worker-এ বাদ দেওয়া হয়েছে, নইলে reset কয়েকবার হতো। আর reset request-টি সাধারণ requests দিয়ে, self.client নয়, যাতে এটি load-এর হিসাবে না ঢোকে। মনে রাখুন, reset endpoint আছে শুধু test mode-এ; shared staging বা production-এ এমন কিছু থাকে না, সেখানে data-র নিয়ম আলাদা (পর্ব ৩১-এর setup আর teardown).

৪ · চালানোর আগে অনুমান — user scheduler-এর একটি মডেল

Load test চালানোর আগে একটি প্রশ্নের উত্তর জানা ভালো: এই workload আসলে কত request পাঠাবে, আর কোন endpoint-এ কত? নইলে run শেষে “২৫ req/s এলো” দেখে বোঝা যায় না সেটি প্রত্যাশিত, না কোথাও গোলমাল। নিচের ব্লকটি এই পাতাতেই চলে। এটি Locust-এর বাছাইয়ের নিয়মের একটি ক্ষুদ্র মডেল: একই weight, একই think time, checkout-এর চার ধাপ, শেষ ধাপের পর বিরতি নেই (interrupt())। লগইন মডেলে নেই। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import random
from collections import Counter

TASKS = {"browse": 6, "search": 3, "product": 4, "Checkout": 1}
CHECKOUT = ["cart", "order", "pay", "cancel"]       # SequentialTaskSet
SLOW = {"browse", "search"}                          # both hit /api/products

def run(users, seconds, slow_ms, seed=47):
    rng, mix = random.Random(seed), Counter()
    names, weights = list(TASKS), list(TASKS.values())
    for _ in range(users):                          # one user at a time
        t = rng.uniform(0, users / 5)               # spawn rate 5 users/s
        while t < seconds:
            task = rng.choices(names, weights)[0]
            steps = CHECKOUT if task == "Checkout" else [task]
            for step in steps:
                if t >= seconds:
                    break
                mix[step] += 1
                t += (slow_ms if step in SLOW else 8) / 1000   # latency
                if step != "cancel":                 # interrupt(): no wait
                    t += rng.uniform(1, 3)           # wait_time = between(1, 3)
    return mix

for slow_ms in (8, 1500):
    mix = run(users=50, seconds=60, slow_ms=slow_ms)
    total = sum(mix.values())
    print(f"search delay {slow_ms:>4} ms -> {total} requests, {total/60:.1f} req/s")
    print("  " + "  ".join(f"{k}={v} ({v/total:.0%})" for k, v in mix.most_common()))

আসল আউটপুট:

search delay    8 ms -> 1480 requests, 24.7 req/s
  browse=529 (36%)  product=374 (25%)  search=248 (17%)  cart=88 (6%)  order=85 (6%)  pay=79 (5%)  cancel=77 (5%)
search delay 1500 ms -> 1032 requests, 17.2 req/s
  browse=393 (38%)  product=250 (24%)  search=173 (17%)  cart=59 (6%)  order=55 (5%)  pay=53 (5%)  cancel=49 (5%)

দুটি শিক্ষা। এক, weight সরাসরি request-এর ভাগ নয়। Browse-এর weight ৬/১৪, প্রায় ৪৩%, অথচ request-এর ভাগ ৩৬%; কারণ checkout-এর একটি বাছাই চারটি request বানায়। দুই, প্রায় প্রতিটি request-এর পরে গড়ে ২ সেকেন্ড বিরতি, তাই ৫০ জন user মোটামুটি ৫০ ÷ ২ ≈ ২৫ req/s দেয়। পরের অংশের সত্যিকারের run-এ এসেছে ১৫০৯টি request (৫০টি লগইনসহ), ২৫.৪ req/s; বসানো ভুলের run-এ ১০৬১টি, ১৭.৯ req/s. মডেলের ১৪৮০ আর ১০৩২-এর সাথে প্রায় মিলে যায়। দ্বিতীয় সারিটি একটি গুরুত্বপূর্ণ সত্য দেখায়: server ধীর হলে user-রা উত্তরের অপেক্ষায় আটকে থাকে, তাই throughput কমে। Throughput কমা মানে চাহিদা কমেছে, এমন নয়।

৫ · Headless run — ৫০ জন user আর NFR-2

Locust-এর একটি web UI আছে, যেখানে user-এর সংখ্যা বসিয়ে live চার্ট দেখা যায়; শেখা আর খোঁজার জন্য ভালো। CI বা পুনরাবৃত্তিযোগ্য run-এর জন্য দরকার headless mode: সব কিছু command line-এ, শেষে রিপোর্ট আর exit code. পর্ব ১৫-এর NFR-2 বলে: ৫০ জন একসাথে থাকলেও p95 ≤ ২ সেকেন্ড। সেটি যাচাইয়ের command:

$ cd ~/bazarghar-load
$ uv add locust                     # Locust 2.47.0, MIT
$ uv run locust -f locustfile.py --headless \
    -u 50 -r 5 -t 60s -H http://127.0.0.1:8822 \
    --csv runA --html runA.html

-u (--users) মোট user, -r (--spawn-rate) প্রতি সেকেন্ডে কতজন যোগ হবে, -t (--run-time) মোট সময়, -H কোন host. --csv runA চারটি ফাইল লেখে: runA_stats.csv (endpoint-ভিত্তিক চূড়ান্ত হিসাব), runA_stats_history.csv (প্রতি সেকেন্ডের হিসাব), runA_failures.csv আর runA_exceptions.csv. --html একটি স্বয়ংসম্পূর্ণ রিপোর্ট বানায়, চার্টসহ, যা CI-এর artifact হিসেবে রাখা যায়।

Telemetry আর বাইরের যোগাযোগ: এই Locust সংস্করণের কোড খুঁজে কোনো ব্যবহার-পরিসংখ্যান পাঠানোর ব্যবস্থা পাওয়া যায়নি। OpenTelemetry-তে তথ্য পাঠানোর একটি ঐচ্ছিক সুবিধা আছে, যা চালু হয় কেবল --otel দিলে আর আলাদা প্যাকেজ বসালে; এই lab-এ দুটির কোনোটিই নেই। তবু অন্য tool-এর মতো এখানেও নতুন সংস্করণের নথি একবার দেখে নেওয়া ভালো অভ্যাস। আর log-এর প্রতিটি লাইনে কম্পিউটারের নাম ছাপা হয়; রিপোর্ট ভাগ করার আগে সেটি সরান।

চালু হওয়ার মুহূর্তে কী ঘটে, সত্যিকারের runA_stats_history.csv থেকে সেকেন্ড ধরে দেখুন:

1Run time limit set to 60 seconds2Ramping to 50 users at a rate of 5.00 per second3(প্রতি সেকেন্ডে ৫ জন যোগ)4All users spawned: {"Shopper": 50}5--run-time limit reached, shutting down
runA_stats_history.csv
সময়
user
মোট req
req/s
p95
  1. শুরু। test_start একবার data reset করে। সময় ০, কোনো user নেই, কোনো request নেই।
  2. প্রথম সেকেন্ড। ৫ জন user জন্মেছে; প্রত্যেকে লগইন আর প্রথম কাজ করেছে, মোট ১০টি request.
  3. তিন সেকেন্ড। ১৫ জন। নতুন user মানে নতুন লগইন, আর লগইনে পাসওয়ার্ড hash (PBKDF2) ধীর কাজ; তাই শুরুর দিকের p95 প্রায় ৫৫ ms, পরে যা নামবে।
  4. পাঁচ সেকেন্ড। ২৫ জন, মোট ৭২টি request, আর Locust এখন req/s দেখাতে শুরু করেছে: ১১.৭.
  5. সব user প্রস্তুত। ৯.১ সেকেন্ডে ৫০ জন পূর্ণ (৫০ ÷ ৫ = ১০ সেকেন্ডের হিসাবের কাছাকাছি)। দশ সেকেন্ডে মোট ২০৮টি request, ১৯ req/s. এখান থেকে স্থির অবস্থা।
  6. শেষ। ৬০ সেকেন্ডে ১৫০৯টি request, গড়ে ২৫.৪ req/s, পুরো run-এর p95 ২৭ ms. শুরুর ramp-এর লগইনগুলোও এই হিসাবে আছে; শুধু স্থির অবস্থা মাপতে চাইলে --reset-stats দিলে সব user জন্মানোর পর stats শূন্য থেকে গোনা হয়।

এবার NFR-2-এর রায়। Console-এর table পড়ে চোখে বিচার না করে, CSV থেকে একটি ছোট script প্রতিটি endpoint-এর p95 মেলায় আর exit code দেয়, যাতে CI-তে কাজে লাগে:

import csv, sys

LIMIT_MS = 2000                                # NFR-2: p95 <= 2 s
prefix = sys.argv[1] if len(sys.argv) > 1 else "run"
bad = 0
with open(f"{prefix}_stats.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        name = row["Name"] if row["Type"] else "(Aggregated)"
        p95 = float(row["95%"])
        n, fails = int(row["Request Count"]), int(row["Failure Count"])
        verdict = "PASS" if p95 <= LIMIT_MS else "FAIL"
        bad += verdict == "FAIL"
        print(f"{verdict}  p95={p95:>6.0f} ms  n={n:<5} fail={fails:<4} {row['Type']} {name}")
print("NFR-2:", "FAILED" if bad else "PASSED")
sys.exit(1 if bad else 0)

সত্যিকারের আউটপুট, run A (কোনো বসানো ভুল নেই):

$ uv run python check_nfr2.py runA
PASS  p95=    61 ms  n=50    fail=0    POST /api/auth/login
PASS  p95=    27 ms  n=85    fail=0    POST /api/cart/items
PASS  p95=    29 ms  n=82    fail=0    POST /api/orders
PASS  p95=    26 ms  n=79    fail=0    POST /api/orders/[id]/pay
PASS  p95=    32 ms  n=78    fail=0    POST /api/orders/[id]/transition
PASS  p95=    19 ms  n=538   fail=0    GET /api/products
PASS  p95=    18 ms  n=329   fail=0    GET /api/products/[id]
PASS  p95=    18 ms  n=268   fail=0    GET /api/products?q=
PASS  p95=    27 ms  n=1509  fail=0     (Aggregated)
NFR-2: PASSED

প্রতিটি endpoint ২ সেকেন্ডের অনেক নিচে; সবচেয়ে ধীর লগইন, ৬১ ms, কারণ সেখানে পাসওয়ার্ড hash হয়। লক্ষ করুন, প্রতিটি সারির পাশে n, অর্থাৎ নমুনার সংখ্যা। লগইনের মাত্র ৫০টি নমুনা; ৫০টির p95 মানে প্রায় তৃতীয় সবচেয়ে ধীর মান, তাই এই সংখ্যা browse-এর ৫৩৮টি নমুনার p95-এর চেয়ে অনেক বেশি নড়বড়ে। কম নমুনার endpoint-এর percentile নিয়ে সিদ্ধান্ত নেওয়ার আগে সংখ্যাটি দেখুন (পর্ব ৪৬-এ percentile-এর হিসাব)।

৬ · বসানো ভুল slow_search — NFR-2 পাস, তবু খারাপ খবর

এবার app একই সেটিংসে চালানো হলো বসানো ভুল slow_search চালু করে: /api/products প্রতিটি request-এ ১৫০০ ms ঘুমায়। Locust-এর command হুবহু এক, শুধু CSV-র নাম runB. শেষে console-এর stats table (সত্যিকারের, প্রস্থের জন্য কয়েকটি সারি বাদ):

Type     Name                     # reqs   # fails |   Avg    Min    Max   Med | req/s
POST     /api/auth/login              50  0(0.00%) |    38     16     60    39 |  0.84
POST     /api/cart/items              53  0(0.00%) |    14     10     40    12 |  0.89
GET      /api/products               353  0(0.00%) |  1505   1502   1537  1502 |  5.90
GET      /api/products/[id]          270  0(0.00%) |     5      2     31     4 |  4.51
GET      /api/products?q=            192  0(0.00%) |  1505   1502   1530  1502 |  3.21
         Aggregated                 1070  0(0.00%) |   772      2   1537  1500 | 17.87

Response time percentiles (approximated)
Name                         50%    95%    99%   100%  # reqs
/api/products               1500   1500   1500   1500     353
/api/products/[id]             4     20     30     31     270
         Aggregated         1500   1500   1500   1500    1070
1login        50  0 | 38 16 60 392products    353  0 | 1505 1502 1537 15023products/[id] 270 0 | 5 2 31 44Aggregated 1070  0 | 772 2 1537 15005p95: products 1500, [id] 20
যা পড়ছি
কলাম
মান
  1. Request আর failure. প্রথমে দেখুন কত নমুনা আর কত failure. লগইনের ৫০টি, কোনো failure নেই। Failure শূন্য মানে ভুল উত্তর নেই, ধীরতা নেই এমন নয়।
  2. Avg আর Med. /api/products-এ গড় ১৫০৫, median ১৫০২, সর্বনিম্ন ১৫০২: প্রায় প্রতিটি request ঠিক ১৫০০ ms ঘুমের পর কয়েক ms কাজ। এমন সরু বিস্তার মানে একটি স্থির দেরি, ভিড় নয়।
  3. দুই table-এ দুই median. Percentile table-এ ৫০% হলো ১৫০০, কারণ শিরোনামেই লেখা “approximated”: Locust ১০০০ থেকে ১০০০০ ms-এর সময় ১০০ ms-এর ঘরে গোল করে রাখে। প্রথম table-এর median সর্বনিম্ন মানের নিচে নামতে দেওয়া হয় না, তাই ১৫০২. ছোট পার্থক্যে বিচলিত হবেন না, কিন্তু জানুন কোথা থেকে আসে।
  4. পাশের endpoint. /api/products/[id] এখনো ৫ ms. ভুলটি একটি endpoint-এ সীমিত; এই load-এ server-এর বাকি অংশ ঠিক আছে। পরের অংশে দেখবেন, load বাড়লে এটি আর সত্য থাকে না।
  5. Aggregated. সব endpoint মিলিয়ে গড় ৭৭২ ms: দ্রুত দল (৫ ms) আর ধীর দলের (১৫০৫ ms) গড়, যা কোনো একজন ব্যবহারকারীর আসল অভিজ্ঞতা নয়। সিদ্ধান্ত নিন endpoint ধরে।
  6. p95-এর রায়। Search-এর p95 ১৫০০ ms, আর ১৫০০ ≤ ২০০০; checker তাই NFR-2 PASSED লিখেছে। অথচ median ৪ থেকে ১৫০০ ms, প্রায় ৩৭৫ গুণ। Requirement পাস, ব্যবহারকারী অসন্তুষ্ট।

পর্ব ৪৬-এ একই বসানো ভুলে ফল ছিল উল্টো: ৫০ জন user বিরতি ছাড়া শুধু /api/products-এ request পাঠিয়েছিল, p95 প্রায় ২.৯ সেকেন্ড, NFR-2 FAIL. দুটি ফলই একই যন্ত্র থেকে আসে। Route-গুলো একটি ৪০টি thread-এর pool-এ চলে; ৫০টি ধীর request একসাথে এলে ১০টি লাইনে দাঁড়ায় আর দ্বিগুণ সময় নেয়। এখানে think time আছে আর অর্ধেকের কম কাজ search, তাই Little-এর সূত্রে একসাথে চলা ধীর request গড়ে প্রায় ৯.১ req/s × ১.৫ s ≈ ১৪টি, ৪০-এর অনেক নিচে; কেউ লাইনে দাঁড়ায় না। একই NFR-2, দুই workload, দুই রায়: এজন্যই requirement-এ workload লেখা জরুরি (ভাবনার প্রশ্ন ০২)।

শেষ ধাপটিই এই অংশের মূল কথা। NFR-2 লেখা হয়েছিল সর্বোচ্চ সহনীয় সীমা হিসেবে; সেটি “আগের চেয়ে খারাপ হয়েছে কি” প্রশ্নের উত্তর দেয় না। তাই পরিণত দল দুই রকম gate রাখে: নির্দিষ্ট সীমা (NFR-2) আর আগের run-এর তুলনা, যাকে বলে baseline. নিচের ব্লকে দুটি run-এর আসল CSV-র কয়েকটি সারি বসানো; script দুই রায়ই দেয়:

import csv, io

BASE = """Name,Request Count,Failure Count,50%,95%
/api/products,538,0,4,19
/api/products/[id],329,0,4,18
/api/products?q=,268,0,4,18
/api/orders,82,0,12,29
"""                                     # runA_stats.csv: clean build
NOW = """Name,Request Count,Failure Count,50%,95%
/api/products,348,0,1500,1500
/api/products/[id],267,0,4,20
/api/products?q=,191,0,1500,1500
/api/orders,51,0,13,33
"""                                     # runB_stats.csv: new build
LIMIT_MS, RATIO, SLACK_MS = 2000, 2.0, 50

def load(text):
    return {r["Name"]: r for r in csv.DictReader(io.StringIO(text))}

base, now = load(BASE), load(NOW)
for name, r in now.items():
    old, p95 = float(base[name]["95%"]), float(r["95%"])
    nfr = "PASS" if p95 <= LIMIT_MS else "FAIL"
    worse = p95 > old * RATIO and p95 - old > SLACK_MS
    print(f"{name:<19} p95 {old:>4.0f} -> {p95:>4.0f} ms"
          f"  NFR-2 {nfr}  {'REGRESSION' if worse else 'ok'}")

আসল আউটপুট:

/api/products       p95   19 -> 1500 ms  NFR-2 PASS  REGRESSION
/api/products/[id]  p95   18 ->   20 ms  NFR-2 PASS  ok
/api/products?q=    p95   18 -> 1500 ms  NFR-2 PASS  REGRESSION
/api/orders         p95   29 ->   33 ms  NFR-2 PASS  ok

চারটি সারিই NFR-2 পাস করে, কিন্তু দুটি সারি baseline-এর তুলনায় regression. তুলনার নিয়মে দুটি শর্ত একসাথে: দ্বিগুণের বেশি এবং অন্তত ৫০ ms বেশি। শুধু অনুপাত রাখলে ২ ms থেকে ৫ ms-এর মতো নগণ্য নড়াচড়াও লাল হতো; শুধু পার্থক্য রাখলে বড় endpoint-এর স্বাভাবিক ওঠানামা। /api/orders-এর ২৯ থেকে ৩৩ ms ঠিক এমন গোলমাল (noise), আর নিয়ম সেটিকে ঠিকই ছেড়ে দিয়েছে। এমন সীমা কীভাবে noise মেপে ঠিক করতে হয়, তা পর্ব ৫০-এর (SLO-ভিত্তিক test আর capacity planning) বিষয়; flaky সংখ্যার পরিসংখ্যান পর্ব ৪০-এ।

৭ · LoadTestShape — ধাপে ধাপে load বাড়িয়ে knee খোঁজা

৫০ জনে NFR-2 পাস করল। প্রশ্ন জাগে: কত জনে ভাঙবে? সমান load-এ এক run এর উত্তর দেয় না। দরকার ধাপে ধাপে বাড়ানো load আর প্রতিটি ধাপে মাপা। Locust-এ এর জন্য LoadTestShape: একটি class, যার tick() প্রতি সেকেন্ডে বলে দেয় এখন কতজন user আর কোন spawn rate, আর None দিলে test থামে। Spike বা ঢেউয়ের মতো load-ও এভাবে লেখা যায়।

from locust import LoadTestShape, between

import locustfile as base                     # same journeys, same reset


class BusyShopper(base.Shopper):              # shorter think time
    wait_time = between(0.5, 1.5)


class StepShape(LoadTestShape):
    step_users, step_s, max_users = 20, 20, 100

    def tick(self):
        t = self.get_run_time()
        if t >= self.step_s * self.max_users // self.step_users:
            return None                       # 100 s total, then stop
        users = (int(t // self.step_s) + 1) * self.step_users
        return (users, self.step_users)       # (user count, spawn rate)

দুটি সিদ্ধান্ত খোলাখুলি বলা দরকার। এক, এই run-এ think time অর্ধেক (০.৫ থেকে ১.৫ সেকেন্ড), কারণ machine budget-এর জন্য সর্বোচ্চ ১০০ জন user; কম বিরতিতে ১০০ জন মোটামুটি স্বাভাবিক বিরতির প্রায় ২০০ জনের সমান চাপ দেয়। রিপোর্টে এটি লিখে রাখতে হয়, নইলে কেউ “১০০ জনে ভাঙে” পড়ে ভুল সিদ্ধান্ত নেবেন। দুই, app-এ slow_search চালু। --csv-full-history দিয়ে চালালে প্রতি সেকেন্ডের হিসাব endpoint ধরে লেখা হয়; একটি ছোট script প্রতিটি ধাপের শেষ সেকেন্ডের সারি তুলে আনে (সেখানে percentile মোটামুটি শেষ ১০ সেকেন্ডের)। সত্যিকারের run:

$ uv run locust -f step_shape.py --headless -H http://127.0.0.1:8822 \
    --csv runC --csv-full-history --html runC.html
… Shape test updating to 20 users at 20.00 spawn rate
… Shape test updating to 40 users at 20.00 spawn rate
…
… Shape test updating to 100 users at 20.00 spawn rate
… Shape test stopping
$ uv run python steps.py runC
users  req/s  p95-all  p95-search  p95-product  fails(total)
   20   12.3     1500        1500           21        0
   40   23.7     1500        1500           21        0
   60   33.8     1500        1500           17        0
   80   46.3     1600        1600          410        0
  100   51.0     1900        1900          490       20

ধাপে ধাপে load: কোথায় বাঁক নেয়

Run C, slow_search on: req/s against users (top), p95 of the fast product endpoint (bottom)

Run C: req/s and product p95 against users; knee between 60 and 80 users 0204060 0250500 20406080100 20406080100 user (জন) req/s সমানুপাতিক হলে p95 /api/products/[id] (ms) knee 490
ছবি ৪৭.১ — ৬০ জন পর্যন্ত req/s প্রায় সমানুপাতিকভাবে বাড়ে আর দ্রুত endpoint-এর p95 ২০ ms-এর আশেপাশে। ৬০ থেকে ৮০-র মাঝে বাঁক: req/s পিছিয়ে পড়ে (১০০-এ ৫১, সমানুপাতিক হলে ৬১.৫), আর এমন একটি endpoint ধীর হয়, যার নিজের কোডে কোনো ভুল নেই।

এই বাঁককে বলে knee. ব্যাখ্যাটি app-এর ভেতরে। বাজারঘরের route-গুলো সাধারণ (sync) Python function, যাদের FastAPI একটি thread pool-এ চালায়; সেই pool-এর ডিফল্ট আকার ৪০টি thread (anyio-র ডিফল্ট)। ধীর search প্রতিটি thread দেড় সেকেন্ড আটকে রাখে। Little-এর সূত্রে (ধীর request-এর হার × ১.৫ s) একসাথে ঘুমন্ত request ৬০ জনে গড়ে প্রায় ২৮টি, ৮০ জনে প্রায় ৩৬টি, ১০০ জনে প্রায় ৪০টি। গড় ৪০-এর নিচে থাকলেও এলোমেলো ভিড়ের মুহূর্তে pool পূর্ণ হয়, আর তখন দ্রুত endpoint-কেও খালি thread-এর জন্য লাইনে দাঁড়াতে হয়। ফলে একটি endpoint-এর ভুল পুরো app-এর সমস্যা হয়ে দাঁড়ায়। সাথে catch_response-এর ফল: ১০০ জনে ২০টি search ২ সেকেন্ড ছাড়িয়েছে, আর Locust সেগুলো failure হিসেবে গুনে রিপোর্টে কারণসহ দেখিয়েছে:

Error report
# occurrences      Error
20                 GET /api/products?q=: slower than NFR-2 (2 s)
… Shape test completed, shutting down
exit=1

Failure থাকলে Locust-এর exit code ডিফল্টে ১ (--exit-code-on-error দিয়ে বদলানো যায়), তাই CI লাল হবে। একই ভুলে আরেকটি run চালানো হয়েছিল ৫০ জন user আর শূন্য think time দিয়ে: p95 ১৯০০ ms, search-এ একটি failure. এখানে ৫০ জনের সবাই search-এ থাকে না (product আর checkout-ও আছে), তাই Little-এর সূত্রে একসাথে ধীর request প্রায় ৪২টি, pool-এর ৪০-এর সামান্য ওপরে, লাইন ছোট; পর্ব ৪৬-এর শুধু-search run-এ ছিল ৫০টি, তাই p95 প্রায় ২.৯ s. আর লক্ষ করুন, latency অসীম হয় না, কারণ ৫০ জন user একসাথে ৫০টির বেশি request রাখতে পারে না, উত্তর না পেলে নতুন request পাঠায় না। Load generator-এর এই “বন্ধ” (closed) আচরণ server-এর আসল ধীরতাকে লুকাতে পারে; পর্ব ৪৬-এ এর নাম coordinated omission, আর পর্ব ৪৮-এ (k6 দিয়ে load test) arrival-rate-ভিত্তিক executor দিয়ে এর প্রতিকার দেখবেন।

৮ · Distributed mode আর load generator-এর সীমা

একটি Locust process একটি CPU core ব্যবহার করে, কারণ greenlet-রা এক thread-এ পালা করে চলে। Generator-এর CPU ৯০%-এর ওপরে উঠলে Locust নিজেই সতর্কবার্তা দেয়, যে throughput আটকে যেতে পারে আর response time-এর মাপ অসংগত হতে পারে। অর্থাৎ ধীরতা তখন server-এর না generator-এর, বোঝা যায় না। এর দুটি প্রতিকার: হালকা client (FastHttpUser, যা geventhttpclient ব্যবহার করে) আর distributed mode: একটি master শুধু হিসাব জোড়ে আর নির্দেশ দেয়, এক বা একাধিক worker user চালায়, একই machine-এর অন্য core-এ বা অন্য machine-এ। এই lab-এ machine budget-এর জন্য শুধু একটি worker, ১০ জন user, ২০ সেকেন্ড; সব যোগাযোগ 127.0.0.1-এ:

$ uv run locust -f locustfile.py --master --master-bind-host 127.0.0.1 \
    --master-bind-port 5577 --expect-workers 1 --headless \
    -u 10 -r 5 -t 20s -H http://127.0.0.1:8822          # টার্মিনাল ১
$ uv run locust -f locustfile.py --worker \
    --master-host 127.0.0.1 --master-port 5577          # টার্মিনাল ২

[master] HOST_c9b7… (index 0) reported as ready. 1 workers connected.
[master] Sending spawn jobs of 10 users at 5.00 spawn rate to 1 ready workers
[master] All users spawned: {"Shopper": 10} (10 total users)
[master] --run-time limit reached, shutting down
[worker] Got quit message from master, shutting down...

--master-bind-host 127.0.0.1 জরুরি: না দিলে master সব network interface-এ শোনে, যা একটি শেয়ার করা network-এ অপ্রয়োজনীয় দরজা খোলা। --expect-workers বলে কতজন worker যুক্ত হলে শুরু হবে। Linux আর macOS-এ --processes দিয়ে এক command-এ কয়েকটি worker fork করা যায়; Locust-এর নিজের সাহায্যবার্তা অনুযায়ী Windows-এ এটি নেই। বড় test-এ generator সবসময় app থেকে আলাদা machine-এ রাখুন; এই পর্বের সংখ্যা একই ল্যাপটপে মাপা, তাই তারা আকার দেখায় (কোথায় knee, কোন endpoint লাইনে দাঁড়ায়), app-এর আসল ক্ষমতা নয়।

উপাদানকাজবাজারঘরে
HttpUser / FastHttpUserএকজন virtual userShopper
@task(n)কাজ আর তার weightbrowse ৬, search ৩, product ৪
wait_timethink timebetween(1, 3)
on_start / on_stopuser-এর শুরু ও শেষের কাজনিজের অ্যাকাউন্টে লগইন
SequentialTaskSetক্রমে চলা যাত্রাকার্ট → অর্ডার → পেমেন্ট → বাতিল
catch_responseনিজে pass/fail বিচারখালি ফল বা ২ s-এর বেশি
eventstest-এর ঘটনায় hooktest_start-এ reset
LoadTestShapeসময়ের সাথে load-এর আকার২০ থেকে ১০০, ধাপে ২০
--csv, --htmlরিপোর্টCSV থেকে NFR-2 যাচাই

আরও গভীরে: Locust-এর percentile হিসাবের জন্য প্রতিটি response time গোল করে ঘরে রাখা হয় (১০০ ms-এর নিচে পুরো মান, তারপর দশ, একশো, হাজারের ঘর); ফলে কম মেমরিতে আর distributed mode-এ অল্প data পাঠিয়ে লাখ লাখ নমুনার percentile পাওয়া যায়, বিনিময়ে নির্ভুলতা কিছুটা কমে। Gil Tene ২০১০-এর দশকের আলোচনায় (“How NOT to Measure Latency” নামে পরিচিত) দেখিয়েছিলেন বলে উল্লেখ করা হয় যে বন্ধ (closed) মডেলের generator ঠিক সেই মুহূর্তগুলোতে নমুনা কম নেয়, যখন system সবচেয়ে ধীর; তাই অনেক দল closed আর open দুই মডেলেই মাপে। বড় পরিসরে generator নিজেই একটি distributed system: ঘড়ি মেলানো, নেটওয়ার্কের দূরত্ব আর worker-এর CPU সবই ফলের অংশ।

পরীক্ষা ও ইন্টারভিউতে:

  • Locust-এ think time কীভাবে দেন, আর না দিলে কী হয়? wait_time = between(a, b) বা অন্য wait function; না দিলে ডিফল্ট শূন্য, user অবিরাম request পাঠায়।
  • Task weight কী? Task বাছাইয়ের আপেক্ষিক সম্ভাবনা; weight ৬ আর ৩ মানে প্রথমটি দ্বিগুণ ঘন ঘন।
  • catch_response কেন? HTTP ২০০ এলেও উত্তর ভুল বা খুব ধীর হলে request-কে নিজে failure চিহ্নিত করতে।
  • Spawn rate কী? প্রতি সেকেন্ডে কতজন নতুন user যোগ হবে; ৫০ জন, rate ৫ মানে প্রায় ১০ সেকেন্ডে পূর্ণ।
  • Server ধীর হলে throughput কেন কমে? Closed মডেলে প্রতিটি user উত্তরের অপেক্ষা করে, তাই কম request পাঠায়; throughput কমা মানে চাহিদা কমা নয়।

৯ · AI-এর যুগে — AI দিয়ে locustfile লেখানো

“বাজারঘরের জন্য একটি Locust load test লিখে দাও” বললে AI সহকারী কয়েক সেকেন্ডে চলনসই দেখতে locustfile দেয়। চেনা ঝুঁকিগুলো: wait_time নেই বা time.sleep দিয়ে বানানো বিরতি; সব user একটি অ্যাকাউন্টে; name= নেই, ফলে প্রতিটি id আলাদা সারি; শুধু সুখী পথ (happy path), ব্যর্থ উত্তর যাচাই নেই; Locust-এ নেই এমন option বা পুরোনো সংস্করণের নাম (যেমন পুরোনো -c/--hatch-rate, যার জায়গায় এখন -u/-r); অবাস্তব user সংখ্যা আর সময়, যা আপনার machine বা শেয়ার করা পরিবেশকে বিপদে ফেলে; বাইরের কোনো আসল URL-কে host বানানো; আর না চালিয়েই “NFR-2 পাস করবে” দাবি।

AI-কে ছোট, নির্দিষ্ট কাজ আর স্পষ্ট সীমা দিন:

তুমি একজন অভিজ্ঞ performance tester. Locust 2.x-এর জন্য একটি locustfile লিখবে, শুধু আমার নিজের local app-এর জন্য (host কমান্ড লাইন থেকে আসবে, কোডে কোনো URL নয়)। নিচে API-র আসল OpenAPI অংশ আর analytics-এর ভাগ দিলাম: browse ৪৩%, product ২৯%, search ২১%, checkout ৭%. নিয়ম: ১. HttpUser, @task weight, wait_time = between(1, 3), on_start-এ লগইন; প্রতিটি user আলাদা test অ্যাকাউন্ট (load001… ধাঁচে)। ২. Checkout একটি SequentialTaskSet; অর্ডার ব্যর্থ হলে বাকি ধাপ বাদ। ৩. id-ওয়ালা প্রতিটি URL-এ name= দিয়ে একটি নাম। ৪. catch_response দিয়ে খালি বা ভুল উত্তর failure. ৫. কোনো time.sleep নয়; কোনো আসল বা আসল-দেখতে secret নয়। ৬. প্রতিটি Locust class, decorator আর CLI option-এর নাম official নথির কোন অংশে আছে, বলবে। ৭. তুমি কোড চালাওনি; কোনো ফল বা "পাস করবে" দাবি করবে না। [এখানে OpenAPI-র অংশ]

AI-এর লেখা locustfile হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১পুরোনো load testing tool-গুলো GUI আর XML-এ test বানাত; Locust বেছে নিল সাধারণ Python কোড। এই সিদ্ধান্তের লাভ আর দাম কী?

Load testing-এর বহুল ব্যবহৃত open-source tool-গুলোর একটি Apache JMeter, যার শুরু ১৯৯০-এর দশকের শেষ দিকে বলে উল্লেখ করা হয়। JMeter-এ test plan বানানো হয় একটি GUI-তে, গাছের মতো সাজানো উপাদান দিয়ে, আর সংরক্ষিত হয় XML ফাইলে। এর সুবিধা স্পষ্ট: কোড না লিখেও request, timer, assertion সাজানো যায়। Locust-এর প্রকল্পের নিজের ইতিহাস-পাতা বলে, তাঁরা তখনকার সমাধানগুলোতে বিরক্ত হয়েই এটি বানান; মূল ভাবনা ছিল user-এর আচরণ সাধারণ Python কোডে লেখা।

কোডের লাভ কয়েকটি। এক, আচরণ যত জটিলই হোক, প্রোগ্রামিং ভাষার পুরো শক্তি হাতে: শর্ত, loop, random, নিজের helper function, বাইরের library. এই পর্বের checkout-এ “অর্ডার ব্যর্থ হলে বাকি ধাপ বাদ” এক লাইনের if; GUI-তে এমন শাখা সাধারণত কয়েকটি controller জুড়ে বানাতে হয়। দুই, কোড version control-এ সহজে পড়া যায়: একটি পরিবর্তনের diff মানে দুই লাইন, XML-এর শত লাইন নয়। তিন, একই code review, linter আর CI-র নিয়ম load test-এও খাটে, ঠিক যেমন পর্ব ৪৫-এ functional test-এর framework-এ।

দাম কী? যিনি Python জানেন না, তাঁর জন্য শুরু কঠিন। কোডের স্বাধীনতা ভুলেরও স্বাধীনতা: কেউ task-এর ভেতরে blocking কাজ রাখতে পারেন, বা self.client-এর বাইরে request পাঠিয়ে stats থেকে হারিয়ে ফেলতে পারেন। আর gevent-ভিত্তিক মডেলে একটি process একটি core-এ চলে, তাই অনেক load-এ distributed mode লাগে, যেখানে কিছু tool একটি process-এ বেশি thread চালায়।

তাই বাছাই প্রেক্ষাপটের। দলে যদি Python-এ functional test লেখা হয়, তবে load test-ও একই ভাষায় থাকলে দলের সবাই পড়তে পারেন, আর API client-এর কোডও ভাগ করা যায়। দলে যদি GUI-ভিত্তিক tool-এ দীর্ঘ অভিজ্ঞতা আর তৈরি plan থাকে, তবে শুধু ফ্যাশনের জন্য বদলানো অর্থহীন। প্রশ্নটি হলো test কে লিখবে, কে রাখবে, আর CI-তে কীভাবে চলবে।

মূল উপলব্ধি: Load test-ও কোড; কোডে লেখা হলে তা review, version control আর CI-র সব সুবিধা পায়, বিনিময়ে প্রোগ্রামিং-এর দক্ষতা আর শৃঙ্খলা দাবি করে।

প্র ০২NFR-2 বলে “৫০ জন একসাথে থাকলে p95 ≤ ২ সেকেন্ড”। এই বাক্যের “একসাথে” কথাটি কেন বিপজ্জনকভাবে অস্পষ্ট, আর ভালো requirement কেমন হতো?

“৫০ জন একসাথে” তিনটি ভিন্ন জিনিস বোঝাতে পারে। এক, ৫০ জন মানুষ app খোলা রেখেছেন, স্বাভাবিক বিরতি দিয়ে কাজ করছেন। দুই, ৫০টি request একই মুহূর্তে server-এ চলছে। তিন, প্রতি সেকেন্ডে ৫০টি নতুন request আসছে। এই পর্বের run-এই তফাত দেখা গেছে: ১–৩ সেকেন্ড think time-এ ৫০ জন user প্রায় ২৫ req/s দিয়েছে; think time শূন্য করলে একই ৫০ জন user ৫০-এর বেশি req/s দিয়েছে, আর slow_search-এ p95 ১৫০০ থেকে ১৯০০ ms-এ উঠেছে। একই বাক্য, দুই রকম চাপ, দুই রকম ফল।

দ্বিতীয় অস্পষ্টতা “কোন কাজের p95”. পর্ব ১৫-এ NFR-2 জন্মেছিল রিভিউ জমার প্রসঙ্গে; এখানে আমরা সব endpoint-এ একই সীমা বসিয়েছি। লগইন, যেখানে পাসওয়ার্ড hash ইচ্ছা করে ধীর, তার সীমা কি search-এর মতোই হবে? আর কতক্ষণের window: পুরো run, নাকি প্রতি পাঁচ মিনিট? Run শুরুর ramp-এর সময় p95 ৫৫ ms ছিল, স্থির অবস্থায় কম; window না বললে দুজন tester একই data থেকে দুই রায় দিতে পারেন।

তৃতীয়, পরিবেশ। একই ল্যাপটপে generator আর app মানে প্রতিযোগিতা; staging-এর আকার production-এর কত ভাগ? Requirement-এ না থাকলে প্রতিটি ফল তর্কসাপেক্ষ।

একটি ভালো রূপ হতে পারে: “Staging-এ (production-এর মতো এক app instance), workload W অনুযায়ী (browse ৪৩%, product ২৯%, search ২১%, checkout ৭%; প্রতি কাজের পর ১–৩ s বিরতি) ৫০ জন সক্রিয় ব্যবহারকারী, অর্থাৎ প্রায় ২৫ req/s-এ, ১০ মিনিটের স্থির অবস্থায় প্রতিটি customer endpoint-এর p95 ≤ ২ s, error ০.১%-এর কম।” এখানে workload, arrival rate, window, endpoint আর ভুলের হার সব লেখা। Workload model আর open বনাম closed মডেলের পুরো আলোচনা পর্ব ৪৬-এ।

মূল উপলব্ধি: “কতজন user” একা কোনো load নয়; think time, request-এর হার, window আর endpoint না বললে performance requirement test করা যায় না, শুধু তর্ক করা যায়।

প্র ০৩Load generator নিজেই কখন মিথ্যা বলে? এই পর্বের মতো একই ল্যাপটপে চালানো ফল কতটা বিশ্বাস করা যায়?

একটি load test-এ দুটি system মাপা হয়, যদিও আমরা ভাবি একটি। Response time মানে generator request পাঠানো থেকে উত্তর পড়া পর্যন্ত সময়; এর মধ্যে generator-এর নিজের দেরিও ঢোকে। Generator ব্যস্ত থাকলে (CPU পূর্ণ, greenlet লাইনে) উত্তর এসে বসে থাকে, পড়া হয় দেরিতে, আর সেই দেরি server-এর নামে লেখা হয়। এ কারণেই Locust ৯০% CPU-র ওপরে সতর্কবার্তা দেয়, আর নথি distributed mode-এর পরামর্শ দেয়।

দ্বিতীয় মিথ্যা আরও সূক্ষ্ম। Closed মডেলে প্রতিটি user আগের উত্তর না পেলে পরের request পাঠায় না। Server যখন সবচেয়ে ধীর, তখনই generator সবচেয়ে কম request পাঠায়, আর ধীর মুহূর্তগুলো নমুনায় কম আসে। Gil Tene এই ঘটনাকে “coordinated omission” নাম দিয়েছিলেন বলে উল্লেখ করা হয়। এই পর্বের শূন্য think time-এর run-এ p95 ২ সেকেন্ডের সামান্য নিচে আটকে থাকা এরই একটি রূপ: ৫০ জনের বেশি কেউ লাইনে দাঁড়াতে পারে না, তাই লাইন অসীম হয় না। বাস্তবে মানুষ এভাবে অপেক্ষা করেন না; নতুন ক্রেতা আসতেই থাকেন।

তৃতীয়, একই machine-এ app আর generator CPU, মেমরি আর disk ভাগ করে। App-এর knee এখানে ৬০ থেকে ৮০ জনের মাঝে দেখা গেছে; আলাদা machine-এ, বেশি core-এ, বা একাধিক worker-এ সংখ্যাটি নিশ্চয়ই বদলাবে।

তাহলে এই ফলের মূল্য কী? আকার আর তুলনা। Knee-এর কারণ (৪০ thread-এর pool ধীর search-এ আটকে যাওয়া) machine বদলালেও থাকে; সংখ্যাটি সরে। একই machine-এ একই সেটিংসে দুটি build-এর তুলনাও অর্থবহ, কারণ দুই দিকে একই পক্ষপাত। কিন্তু “বাজারঘর ৬০ জন সামলায়” কথাটি capacity-র দাবি হিসেবে লেখা যায় না। Capacity-র দাবির জন্য production-এর কাছাকাছি পরিবেশ, আলাদা generator আর generator-এর নিজের CPU-র রেকর্ড লাগে (পর্ব ৫০)।

মূল উপলব্ধি: Load test-এর ফল generator আর app দুটিরই ছবি; একই ল্যাপটপের সংখ্যা তুলনা আর কারণ খোঁজায় কাজে লাগে, capacity-র প্রতিশ্রুতিতে নয়।

প্র ০৪Load test-এর test data কেন functional test-এর চেয়ে কঠিন? এই পর্বের অ্যাকাউন্ট, স্টক আর search শব্দের সিদ্ধান্তগুলো কী শেখায়?

Functional test-এ সাধারণত একটি test, একটি অবস্থা, একটি ব্যবহারকারী। Load test-এ একই সময়ে শত শত user একই data-য় হাত দেয়, অনেক মিনিট ধরে। তিন রকম সমস্যা জন্মায়: সংঘর্ষ, ক্ষয় আর অবাস্তব সুবিধা।

সংঘর্ষ: বাজারঘরের চারজন seed ক্রেতাকে ৫০ জন user ভাগ করলে একই কার্টে অনেকে লিখত, একজনের অর্ডার আরেকজনের কার্ট খালি করত, আর রিপোর্টে আসত cart_empty-এর ঝাঁক। এই failure app-এর নয়, test-এর নকশার। সমাধান ছিল প্রতিটি user-এর আলাদা অ্যাকাউন্ট, যা নিজের app কপিতে test mode-এর seed-এ যোগ করতে হয়েছে। বাস্তব দলে এর জন্য আলাদা test অ্যাকাউন্ট তৈরির script বা API থাকে।

ক্ষয়: প্রতিটি অর্ডার স্টক কমায়। তেলের ৩০ বোতল কয়েক মিনিটেই শেষ হতো, তারপর ৪০৯ insufficient_stock, আর load test-এর দ্বিতীয় অর্ধেক মাপত অন্য একটি app-কে: যে শুধু “স্টক নেই” বলে। তাই প্রতিটি যাত্রা শেষে বাতিল, যা স্টক ফেরায়। Soak test-এর মতো দীর্ঘ run-এ এই প্রশ্ন আরও বড়: database বড় হয়, log জমে, আর app-এর গতি data-র আকারের সাথে বদলায়।

অবাস্তব সুবিধা: সব user একই পণ্য বা একই search শব্দ চাইলে cache সব উত্তর মনে রাখে, আর ফল বাস্তবের চেয়ে ভালো আসে। এখানে চারটি শব্দ আর আটটি পণ্য থেকে এলোমেলো বাছাই; বড় system-এ শব্দের তালিকা আসে আসল search log-এর বেনামি নমুনা থেকে, ব্যক্তিগত তথ্য বাদ দিয়ে।

আর টাকার ধাপে বাড়তি সতর্কতা: প্রতিটি পেমেন্টে Idempotency-Key, যাতে load-এর চাপে timeout আর retry হলেও দুইবার charge না হয় (বাজারঘরের জানা UI ত্রুটির কথা মনে করুন, পর্ব ৩৭)। Load test কখনো আসল payment gateway-তে নয়; এখানে cash আর নকল gateway.

মূল উপলব্ধি: Load test-এর data-কে একই সাথে আলাদা, টেকসই আর বাস্তবসম্মত হতে হয়; নইলে রিপোর্ট test-এর নিজের ভুল বা কৃত্রিম সুবিধা মাপে।

প্র ০৫slow_search-এ search ৩৭৫ গুণ ধীর হলো, তবু NFR-2 পাস। Performance-এর gate শুধু নির্দিষ্ট সীমায় রাখলে কী হারায়, আর শুধু তুলনায় রাখলে কী?

নির্দিষ্ট সীমা (যেমন p95 ≤ ২ s) ব্যবহারকারীর সহনশীলতার কথা বলে: এর বেশি হলে অভিজ্ঞতা অগ্রহণযোগ্য। এটি জরুরি, কারণ ধীরে ধীরে খারাপ হওয়া একটি system প্রতিটি build-এ “আগের চেয়ে একটু খারাপ” হয়েও কোনো তুলনামূলক gate-এ ধরা না পড়তে পারে; দশ build পরে সে সীমা পেরোয়। কিন্তু সীমা সাধারণত আজকের গতির অনেক ওপরে রাখা হয়, আর মাঝের ফাঁকে বড় regression লুকিয়ে থাকে। এই পর্বে median ৪ থেকে ১৫০০ ms; সীমা পাস।

লুকানো regression-এর দাম আছে। প্রথমত, headroom শেষ: আজ ১৫০০ ms, পাশের একটি ছোট পরিবর্তন বা একটু বেশি ভিড়ে সীমা পার। Step run-এ ঠিক এটাই দেখা গেছে: ১০০ জনে p95 ১৯০০ আর ২০টি request ২ সেকেন্ডের বেশি। দ্বিতীয়ত, ধীর endpoint শেয়ার করা সম্পদ (এখানে thread pool) খায়, আর অন্য endpoint-কে ধীর করে, যার নিজের সীমা হয়তো কড়া।

শুধু তুলনা (baseline) রাখলে উল্টো সমস্যা। প্রতিটি run-এ কিছু গোলমাল থাকে: /api/orders-এর p95 ২৯ থেকে ৩৩ ms হওয়া কোনো ভুল নয়। তুলনা খুব কড়া হলে CI প্রায়ই মিথ্যা লাল হয়, আর দল লাল দেখা বন্ধ করে, যেমন flaky functional test-এ হয় (পর্ব ৪০)। তাই তুলনায় দরকার অনুপাত আর ন্যূনতম পার্থক্য দুটিই, কয়েকটি run-এর গড় বা median baseline, আর একই পরিবেশ। আর baseline নিজে খারাপ হলে (আগের build-ই ধীর) তুলনা সেটিকে স্বাভাবিক মেনে নেয়; সীমা সেখানে রক্ষাকবচ।

বাস্তবে তাই দুটি একসাথে: সীমা ঠিক করে “কখনো এর বেশি নয়”, তুলনা বলে “হঠাৎ খারাপ হলো কেন”। পর্ব ৫০-এ এই ধারণা SLO আর error budget-এর ভাষায় পরিণত রূপ পাবে।

মূল উপলব্ধি: নির্দিষ্ট সীমা ব্যবহারকারীকে রক্ষা করে, baseline-এর তুলনা দলকে আগাম সতর্ক করে; একটি ছাড়া অন্যটি অর্ধেক পাহারা।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন।

  1. Spec থেকে workload: বাজারঘরের analytics: দর্শনের ৫০% তালিকা ঘোরা, ২৫% search, ২০% পণ্যের পাতা, ৫% কেনাকাটার পূর্ণ যাত্রা (কার্ট, অর্ডার, পেমেন্ট)। প্রতি কাজের পর মানুষ ২ থেকে ৪ সেকেন্ড থামেন। (ক) Locust-এর weight আর wait_time লিখুন। (খ) ৫০ জন user মোটামুটি কত req/s দেবে, server দ্রুত ধরে? (গ) কেনাকাটার যাত্রায় কোন দুটি জিনিস না রাখলে run কয়েক মিনিটে নষ্ট হবে?

    (ক) @task(10) browse, @task(5) search, @task(4) product, আর tasks = {Checkout: 1} (৫০:২৫:২০:৫-এর অনুপাত ১০:৫:৪:১-এর সমান); wait_time = between(2, 4). (খ) প্রায় প্রতিটি request-এর পরে গড়ে ৩ সেকেন্ড বিরতি, server-এর সময় নগণ্য, তাই ৫০ ÷ ৩ ≈ ১৬.৭ req/s; checkout-এর এক বাছাই কয়েকটি request দেয় বলে ভাগ বদলাবে, মোট প্রায় একই। চালানোর পর বড় পার্থক্য দেখলে আগে locustfile সন্দেহ করুন। (গ) প্রতিটি user-এর আলাদা অ্যাকাউন্ট (নইলে কার্টে সংঘর্ষ), আর স্টকের ক্ষয় ঠেকানো (যাত্রা শেষে বাতিল বা প্রতি run-এর আগে reset ও যথেষ্ট স্টক)। পেমেন্টে Idempotency-Key-ও রাখুন।

  2. Stats পড়ুন আর ফল অনুমান করুন: একটি step run-এর হিসাব (search-এ ১.৫ s-এর বসানো দেরি, think time ০.৫–১.৫ s): user ৬০ → req/s ৩৩.৮, product-এর p95 ১৭ ms; user ৮০ → req/s ৪৬.৩, product-এর p95 ৪১০ ms; user ১০০ → req/s ৫১.০, product-এর p95 ৪৯০ ms, ২০টি failure “slower than NFR-2 (2 s)”. (ক) Product endpoint-এর কোডে কোনো পরিবর্তন নেই; তবু কেন ধীর? (খ) ১০০ জনে req/s সমানুপাতিক হলে কত হতো? (গ) Locust-এর exit code কত হবে?

    (ক) সব sync route একই thread pool ভাগ করে (এখানে ৪০টি thread); ধীর search প্রতিটি thread দেড় সেকেন্ড আটকে রাখে, ফলে ৬০ জনের পর pool প্রায় পূর্ণ, আর দ্রুত product request-কেও খালি thread-এর লাইনে দাঁড়াতে হয়। এটাই knee. (খ) ২০ জনে ১২.৩ ধরলে ১০০ জনে ৬১.৫; পাওয়া গেছে ৫১.০, অর্থাৎ system আর সমানুপাতিকভাবে কাজ নিতে পারছে না। (গ) Failure আছে, তাই ডিফল্টে ১ (--exit-code-on-error না বদলালে); সত্যিকারের run-এও exit=1.

  3. এই locustfile-এ ভুল খুঁজুন: একজন সহকর্মীর লেখা; অন্তত ছয়টি সমস্যা খুঁজুন।
    import time, requests
    from locust import HttpUser, task
    
    class Buyer(HttpUser):
        host = "https://www.example-shop.com"
    
        @task
        def look(self):
            for pid in range(1, 13):
                self.client.get(f"/api/products/{pid}")
    
        @task
        def buy(self):
            r = self.client.post("/api/auth/login", json={
                "email": "mitu@bazarghar.test", "password": "mitu1234"})
            requests.post(self.host + "/api/orders", json={"district": "Dhaka"})
            time.sleep(2)

    (১) Host একটি বাইরের website: load দেওয়া যায় শুধু নিজের, অনুমতিপ্রাপ্ত app-এ; host কোডে না রেখে -H দিয়ে নিজের 127.0.0.1. (২) wait_time নেই: ডিফল্ট শূন্য, user-রা অবিরাম request পাঠাবে। (৩) name= নেই: ১২টি id মানে stats-এ ১২টি আলাদা সারি। (৪) প্রতিটি কেনায় নতুন লগইন: লগইন হওয়া উচিত on_start-এ একবার; নইলে ধীর পাসওয়ার্ড hash load-এর বড় অংশ হয়ে যায়। (৫) সব user একই অ্যাকাউন্ট (mitu), আর পাসওয়ার্ড কোডে লেখা। (৬) অর্ডার requests.post দিয়ে: Locust-এর stats-এ আসবে না, আর token-ও যাচ্ছে না, তাই ৪০১ পাবে কিন্তু কেউ জানবে না। (৭) অর্ডারের body অসম্পূর্ণ (ঠিকানা, ফোন, পেমেন্ট নেই) আর কার্টে কিছু যোগ হয়নি; ফলাফল যাচাইও নেই (catch_response). (৮) time.sleep(2) task-এর ভেতরে: think time-এর জায়গা wait_time; এখানে এটি কাজের অংশ মনে হয় আর ইচ্ছাটি অস্পষ্ট। (৯) Weight নেই: দেখা আর কেনা সমান ঘন ঘন, যা বাস্তব নয়।

  4. একটি shape নকশা করুন: আপনি জানতে চান ১০ থেকে ৫০ জনের মধ্যে কোথায় knee. Load শুরু হবে ১০ জনে, প্রতি ১৫ সেকেন্ডে ১০ জন করে বাড়বে, ৫০ জনের ধাপ শেষ হলে থামবে। (ক) মোট কত সেকেন্ড চলবে? (খ) tick() লিখুন। (গ) রিপোর্টে প্রতিটি ধাপের কোন তিনটি সংখ্যা দেখবেন?

    (ক) পাঁচটি ধাপ (১০, ২০, ৩০, ৪০, ৫০), প্রতিটি ১৫ সেকেন্ড: ৭৫ সেকেন্ড। (খ)

    def tick(self):
        t = self.get_run_time()
        if t >= 75:
            return None
        return ((int(t // 15) + 1) * 10, 10)

    (গ) প্রতিটি ধাপের শেষে req/s (সমানুপাতিকভাবে বাড়ছে কি না), প্রতিটি গুরুত্বপূর্ণ endpoint-এর p95 (হঠাৎ লাফ), আর failure-এর সংখ্যা। --csv-full-history দিলে প্রতি সেকেন্ডের হিসাব endpoint ধরে পাওয়া যায়। ধাপ খুব ছোট হলে percentile-এর window (প্রায় ১০ সেকেন্ড) আগের ধাপের সাথে মিশে যায়; তাই ধাপ অন্তত ১৫–২০ সেকেন্ড রাখা ভালো।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমLocust দিয়ে একটি নতুন build-এর load test-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Analytics থেকে workload আর NFR থেকে সীমা লেখা
  2. Locustfile-এ user, task-এর weight, think time আর যাত্রা লেখা
  3. আলাদা অ্যাকাউন্টসহ test data প্রস্তুত আর reset করা
  4. পুরোনো build-এ একই সেটিংসে baseline run
  5. নতুন build-এ হুবহু একই command-এ run
  6. CSV থেকে প্রতিটি endpoint-এর p95 সীমা আর baseline-এর সাথে মেলানো

একটি Locust user-এ @task(6) browse, @task(3) search, @task(4) product আর tasks = {Checkout: 1}. কোনো একটি বাছাইয়ে browse ওঠার সম্ভাবনা কত?

  • ৬%
  • ২৫%
  • প্রায় ৪৩% (৬/১৪)
  • ৬০%

Locust headless mode-এ -u 50 -r 5 -t 60s দিয়ে চালানো হলো। কোনটি সঠিক?

  • প্রতি সেকেন্ডে ৫টি request পাঠানো হবে
  • প্রায় ১০ সেকেন্ডে ৫০ জন user পূর্ণ হবে, তারপর মোট ৬০ সেকেন্ড পর্যন্ত চলবে
  • প্রতিটি user ৬০ সেকেন্ড করে চলবে, পালা করে
  • ৫ জন user ৫০ সেকেন্ড চলবে

একটি search endpoint HTTP 200 দেয়, কিন্তু body-তে "total": 0, যদিও খোঁজা শব্দের পণ্য আছে। Locust-এর ডিফল্ট আচরণে এটি কী গোনা হয়, আর কীভাবে ধরবেন?

  • Failure, কারণ Locust নিজেই body যাচাই করে
  • Exception, আর exceptions.csv-তে যায়
  • wait_time বাড়ালে failure দেখা যাবে
  • সফল গোনা হয়; catch_response=True দিয়ে body যাচাই করে r.failure() ডাকতে হয়

একটি locustfile-এ self.client.get(f"/api/products/{pid}"), যেখানে pid ১ থেকে ১২-র মধ্যে এলোমেলো। name="/api/products/[id]" যোগ করলে কী লাভ?

  • সব id-র request এক সারিতে গোনা হয়, তাই endpoint-এর percentile যথেষ্ট নমুনায় হিসাব হয়
  • Server-এ [id] লেখা URL পাঠানো হয়
  • Request দ্রুত হয়
  • ভুল id-র request বাদ পড়ে

৫০ জন user, think time ১–৩ s. দ্রুত build-এ throughput ২৫.৪ req/s; search-এ ১.৫ s-এর বসানো দেরিসহ একই সেটিংসে ১৭.৯ req/s. Throughput কমার সঠিক ব্যাখ্যা কোনটি?

  • কিছু user ভয়ে চলে গেছে
  • Locust-এর CPU পূর্ণ হয়ে গেছে
  • প্রতিটি user উত্তরের অপেক্ষায় আটকে থাকে, তাই প্রতি user কম request পাঠায়
  • Server অর্ধেক request প্রত্যাখ্যান করেছে

একটি Locust run শেষে stats-এ ২০টি failure (catch_response দিয়ে চিহ্নিত ধীর request), আর কোনো exit-code-এর option দেওয়া হয়নি। CI-তে কী হবে?

  • Exit code ০, CI সবুজ
  • Exit code ১, CI লাল
  • Exit code ২০, CI লাল
  • প্রথম failure-এ run থেমে যাবে

ধাপে ধাপে load বাড়ানোর একটি run-এ ৬০ জন পর্যন্ত req/s প্রায় সমানুপাতিকভাবে বাড়ে, আর একটি দ্রুত endpoint-এর p95 প্রায় ২০ ms. ৮০ জনে req/s পিছিয়ে পড়ে আর সেই endpoint-এর p95 ৪১০ ms. এই বিন্দুকে কী বলে, আর এটি কী নির্দেশ করে?

  • Warm-up; শুরুর ধীরতা কেটে যাচ্ছে
  • Spike; হঠাৎ ভিড়ের পরীক্ষা
  • ওই endpoint-এর কোডে নতুন bug
  • Knee; কোনো শেয়ার করা সম্পদ পূর্ণ হতে চলেছে, request লাইনে দাঁড়াচ্ছে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Load = আচরণ: user, task-এর weight, think time আর যাত্রা মিলে workload; শুধু user-এর সংখ্যা কোনো load নয়।
  2. সৎ load test: প্রতিটি user-এর আলাদা অ্যাকাউন্ট, যাত্রা শেষে পরিষ্কার, Idempotency-Key, id-ওয়ালা URL-এ name=, আর catch_response দিয়ে ভুল উত্তর failure.
  3. Headless আর CSV: -u -r -t --csv; রায় দিন endpoint ধরে p95 আর নমুনার সংখ্যা দেখে, aggregated গড়ে নয়।
  4. দুই gate: slow_search-এ NFR-2 পাস, অথচ median ৪ থেকে ১৫০০ ms; নির্দিষ্ট সীমার সাথে baseline-এর তুলনাও লাগে।
  5. Knee আর generator: Step load-এ ৬০–৮০ জনে thread pool পূর্ণ হয়ে দ্রুত endpoint-ও ধীর; একই ল্যাপটপের সংখ্যা আকার দেখায়, capacity নয়।

পরের পর্বে: k6 দিয়ে load test — scenario আর executor, check বনাম threshold, p(95)<2000 লিখে NFR-2-কে exit code বানানো, আর arrival rate দিয়ে open মডেলে একই slow_search কেমন দেখায়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান