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

SLO-ভিত্তিক test আর capacity planning

SLO-Based Performance Testing and Capacity Planning

Taught in Bangla, this lesson turns SLIs, SLOs, SLAs and error budgets into measurable tests. A real CI gate compares each build with the SLO and the previous baseline under noise, catching a 60 ms regression inside the SLO with exit code 1. An M/M/1 model shows p95 rising about five times from 50 to 90 percent utilisation, and a stress run plateaus near 750 requests per second. One versus two workers, overload recovery, a short soak run and sale-day capacity planning with headroom follow.

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

  • SLI, SLO, SLA আর error budget আলাদা করা, আর একটি SLO থেকে মাপা যায় এমন performance test বানানো
  • CI-তে একটি performance gate লেখা, যা SLO আর আগের baseline দুটোর সাথে তুলনা করে, noise মেনে
  • Utilisation আর latency-র সম্পর্ক queueing মডেল দিয়ে বোঝা, আর একটি stress run-এর curve পড়া
  • ১ বনাম ২ worker, stress থেকে ভাঙন ও ফিরে আসা, আর ছোট soak run নিজে চালিয়ে ফল বিচার করা
  • সেল-দিনের জন্য headroom আর N+1 ধরে capacity plan করা, আর autoscaling-এর সীমা বোঝা

১ · মাপ, লক্ষ্য আর চুক্তি — SLI, SLO, SLA

ঢাকা-চট্টগ্রামের একটি বাস কোম্পানির কথা ভাবুন। কাউন্টারের ম্যানেজার প্রতিদিন খাতায় লেখেন কোন বাস কত মিনিট দেরিতে ছাড়ল; এটি মাপ। কোম্পানি নিজেরা ঠিক করেছে, “মাসে ৯৫% বাস ১৫ মিনিটের মধ্যে ছাড়বে”; এটি লক্ষ্য। আর একটি কর্পোরেট অফিসের সাথে চুক্তি আছে: “মাসে ৯০%-এর কম সময়মতো হলে পরের মাসে কিছু টিকিট ফ্রি”; এটি চুক্তি। লক্ষ্যটি চুক্তির চেয়ে কড়া, যাতে চুক্তি ভাঙার আগেই কোম্পানি সতর্ক হয়।

সফটওয়্যারে এই তিনটির নাম SLI, SLO আর SLA. Google-এর প্রকৌশলীদের লেখা “Site Reliability Engineering” বই (২০১৬ সালে প্রকাশিত) এই শব্দগুলো ব্যাপক জনপ্রিয় করে বলে সাধারণত ধরা হয়। SLI হলো ব্যবহারকারীর অভিজ্ঞতার একটি মাপা সংখ্যা, সাধারণত “ভালো ঘটনা ÷ মোট ঘটনা”. SLO হলো সেই সংখ্যার লক্ষ্য, একটি সময়ের জানালাসহ (SLO window). SLA হলো লিখিত চুক্তি, যেখানে লক্ষ্য না মিললে পরিণতি থাকে। এই ধারণাগুলোর পূর্ণ আলোচনা, burn-rate alert আর on-call আছে সিস্টেম ডিজাইন কোর্সের পর্ব ৫০-এ আর ক্লাউড ও DevOps কোর্সের পর্ব ৬৬-এ। এখানে প্রশ্ন tester-এর: SLO থেকে test কীভাবে বানাই?

পর্ব ১৫-এ (Requirement থেকে test) রিভিউ feature-এর জন্য একটি non-functional requirement লেখা হয়েছিল: NFR-2, “৫০ জন একসাথে থাকলেও জমার সাড়ার p95 ≤ ২ সেকেন্ড”. এটি release-এর আগের শর্ত; SLO হলো production-এ চলমান জানালায় মাপা লক্ষ্য। Tester দুটোকেই load test-এর pass/fail-এ বদলান।

কীবাজারঘরের উদাহরণ (কাল্পনিক)কে ঠিক করে
SLIমাপা অনুপাত৩০০ ms-এর মধ্যে HTTP 2xx পাওয়া search request ÷ সব বৈধ search requestপ্রকৌশল দল, ব্যবহারকারীর চোখে
SLOলক্ষ্য + জানালাচলমান ২৮ দিনে SLI ≥ ৯৯.৫%পণ্য আর প্রকৌশল একসাথে
SLAচুক্তি + পরিণতিএকটি পাইকারি অংশীদারের সাথে: মাসে ৯৯% না হলে creditব্যবসা আর আইন বিভাগ
Error budgetমেনে নেওয়া খারাপের পরিমাণ২৮ দিনের মোট search-এর ০.৫%SLO থেকে হিসাব

লক্ষ করুন, latency-র SLO একটি percentile-এর ভাষায়, গড়ের ভাষায় নয়। “গড় ২০০ ms” লক্ষ্য হলে দশ জনের একজন ৩ সেকেন্ড অপেক্ষা করলেও গড় ঠিক দেখাতে পারে; percentile আর গড়ের এই ফাঁদ পর্ব ৪৬-এ (Performance testing-এর ধারণা) বিস্তারিত দেখেছেন। দুটি লেখার ধরন প্রচলিত, আর দুটির test আলাদা: (ক) “৯৫তম percentile ≤ ৩০০ ms”, যা একটি load test-এর শেষে সরাসরি মাপা যায়; (খ) “৯৯.৫% request ভালো, যেখানে ভালো মানে ৩০০ ms-এর মধ্যে সফল”, যা ঘটনা গুনে মাপা হয় আর error budget-এর হিসাবের জন্য সুবিধাজনক। নিচের stepper-এ একটি request-এর log থেকে release-এর সিদ্ধান্ত পর্যন্ত পথটি দেখুন।

  1. ঘটনাaccess logপ্রতিটি request
  2. SLIgood / validমাপ
  3. SLO99.5% / 28dলক্ষ্য
  4. Budget0.5%কতটা খারাপ চলে
  5. Test gatep95 ≤ 300release-এর আগে
search-এর তিনটি ঘটনাকাঁচা data
GET /api/products?q=oil  200  41 ms
GET /api/products?q=চাল  200  512 ms
GET /api/products?q=tea  503    3 ms
# সময়, status, endpoint: SLI-এর কাঁচামাল
SLI-এর সংজ্ঞাভালো কোনটি
valid = সব search (4xx-এ ক্লায়েন্টের দোষ বাদ)
good  = status 2xx এবং সময় ≤ 300 ms
৩টির মধ্যে ভালো ১টি → SLI = 33.3%
512 ms সফল হলেও "ভালো" নয়
SLOলক্ষ্য + জানালা
চলমান ২৮ দিনে SLI ≥ 99.5%
# জানালা ছাড়া শতাংশ অর্থহীন:
# এক ঘণ্টার 99.5% আর মাসের 99.5% আলাদা
Error budgetউল্টো দিক
2,205,000 search / 28 দিন
× 0.005 = 11,025টি খারাপ চলবে
শেষ হলে: ঝুঁকিপূর্ণ release থামান
perf_gate.pyCI-তে
৫০ ব্যবহারকারী, ৪৫ s, search-এর p95
p95 ≤ 300 ms  আর  error ≤ 1%
baseline থেকে +20% ও +15 ms-এর বেশি নয়
না মিললে exit 1 → release থামে
  1. ঘটনা। প্রতিটি request একটি লাইন রেখে যায়: কোন endpoint, কোন status, কত সময়। SLI বানানো হয় এই কাঁচা ঘটনা থেকে, তাই log বা metric ঠিকমতো না থাকলে SLO-ও মাপা যায় না।
  2. SLI. আগে ঠিক করতে হয় কোন ঘটনা গোনা হবে (valid) আর কোনটি ভালো। এখানে ভালো মানে সফল এবং ৩০০ ms-এর মধ্যে; তাই ৫১২ ms-এর সফল উত্তরও খারাপ। তিনটির মধ্যে ভালো একটি।
  3. SLO. লক্ষ্য একটি জানালাসহ: চলমান ২৮ দিনে ৯৯.৫%. জানালা না বললে কেউ এক ঘণ্টার ভালো সময় দেখিয়ে “লক্ষ্য পূরণ” দাবি করতে পারেন।
  4. Error budget. ৯৯.৫%-এর উল্টো দিক ০.৫%: এই জানালায় ২২,০৫,০০০ search হলে ১১,০২৫টি খারাপ মেনে নেওয়া যায়। বাজেট নীতির ভাষা: শেষ হলে নতুন ঝুঁকি নয়, আগে স্থিরতা।
  5. Test gate. Production-এ ২৮ দিন অপেক্ষা না করে release-এর আগেই একটি load test একই লক্ষ্যের ছোট রূপ যাচাই করে: p95, error-এর হার আর আগের build-এর তুলনা। না মিললে CI লাল।

২ · Error budget — খারাপের বাজেট, আর সেল-সপ্তাহের ফাঁদ

মাসের শুরুতে বাড়ির খরচের একটি বাজেট থাকে। কোন সপ্তাহে কত খরচ হলো, আর এই হারে চললে মাস শেষের আগে টাকা ফুরাবে কি না, সেটি দেখেই সিদ্ধান্ত হয়। Error budget একই কাজ করে খারাপ request-এর জন্য। ৯৯.৫% SLO মানে জানালার ০.৫% request খারাপ হলেও লক্ষ্য রক্ষা পায়। এই বাজেট থেকে নতুন feature-এর ঝুঁকি, পরীক্ষামূলক release, এমনকি পরিকল্পিত রক্ষণাবেক্ষণের খরচ মেটে।

বাজেট কত দ্রুত পুড়ছে, তার মাপ burn rate: একটি সময়ে খারাপের হার ÷ অনুমোদিত হার। ১ মানে ঠিক সময়সূচিতে খরচ, ২ মানে জানালার অর্ধেক সময়েই বাজেট শেষ। নিচের ব্লকে বাজারঘরের search-এর চার সপ্তাহের কাল্পনিক হিসাব; চতুর্থ সপ্তাহটি ঈদের সেল-সপ্তাহ, যখন ভিড় দ্বিগুণের বেশি। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

SLO = 0.995                  # 99.5% of search requests: OK and within 300 ms
WINDOW_DAYS = 28

# invented weekly counts for বাজারঘর search: (total, bad)
weeks = [(410_000, 1_150), (395_000, 980), (420_000, 2_400), (980_000, 6_900)]

total = sum(t for t, _ in weeks)
bad = sum(b for _, b in weeks)
budget = (1 - SLO) * total            # bad events allowed in 28 days
print(f"window={WINDOW_DAYS}d requests={total:,} allowed_bad={budget:,.0f}")

spent = 0
for i, (t, b) in enumerate(weeks, 1):
    spent += b
    burn = (b / t) / (1 - SLO)        # 1.0 = spending exactly on schedule
    print(f"week {i}: good={1 - b / t:.3%}  burn_rate={burn:.2f}  "
          f"budget_left={1 - spent / budget:6.1%}")

sli = 1 - bad / total
print(f"28-day SLI={sli:.3%}  ->  SLO {'met' if sli >= SLO else 'MISSED'}")

for slo in (0.99, 0.995, 0.999):      # the same idea as time per 30 days
    print(f"SLO {slo:.1%}: bad time allowed = {(1 - slo) * 30 * 24 * 60:.1f} min / 30 days")

আসল আউটপুট:

window=28d requests=2,205,000 allowed_bad=11,025
week 1: good=99.720%  burn_rate=0.56  budget_left= 89.6%
week 2: good=99.752%  burn_rate=0.50  budget_left= 80.7%
week 3: good=99.429%  burn_rate=1.14  budget_left= 58.9%
week 4: good=99.296%  burn_rate=1.41  budget_left= -3.7%
28-day SLI=99.482%  ->  SLO MISSED
SLO 99.0%: bad time allowed = 432.0 min / 30 days
SLO 99.5%: bad time allowed = 216.0 min / 30 days
SLO 99.9%: bad time allowed = 43.2 min / 30 days

প্রথম দুই সপ্তাহ শান্ত: burn rate ১-এর নিচে, বাজেটের ৮০% বাকি। তৃতীয় সপ্তাহে burn rate ১.১৪, তবু ৫৯% বাকি, তাই কেউ চিন্তিত নন। চতুর্থ সপ্তাহের burn rate মাত্র ১.৪১, অথচ বাজেট শেষ হয়ে ঋণাত্মক (−৩.৭%), আর ২৮ দিনের SLI ৯৯.৪৮২%, লক্ষ্যের সামান্য নিচে। কারণ বাজেটটি ঘটনার সংখ্যায়: সেল-সপ্তাহে request ৯,৮০,০০০, তাই একই ধরনের error-এর হারে খারাপের সংখ্যা অনেক বেশি। শিক্ষা দুটি। এক, সেলের আগে load test শুধু “চলে কি না” নয়, error-এর হারও মাপুক। দুই, শেষ তিন লাইন সময়ের ভাষায় একই ধারণা: ৯৯.৯% মানে ৩০ দিনে মোট ৪৩.২ মিনিট খারাপ সময়; প্রতিটি “৯” যোগ করলে বাজেট দশ ভাগের এক ভাগ। এবার নিজে চতুর্থ সপ্তাহের খারাপ সংখ্যা 6_900 থেকে কমিয়ে দেখুন, কোন মানে SLO আবার “met” হয়।

SLO নিজে test নয়: production-এর SLO ২৮ দিন পরে জানায় লক্ষ্য রক্ষা পেল কি না। Tester-এর কাজ আগে জানা। তাই release-এর আগে load test-এ একই সংজ্ঞা (কোন endpoint, কোন percentile, কোন সীমা, কোন error) ব্যবহার করুন, আর test-এর ভার সেলের প্রত্যাশিত ভিড় থেকে নিন, সাধারণ দিনের থেকে নয়।

৩ · SLO থেকে CI gate — সত্যিকারের run আর noise

এই পর্বের সব সত্যিকারের run আলাদা scratch ফোল্ডারে, uv দিয়ে বানানো দুটি virtual environment-এ: বাজারঘরের app (MIT) নিজের কপি থেকে 127.0.0.1:8825-এ, test mode-এ, নিজের database ফাইলে, Uvicorn 0.54.0 দিয়ে; আর load generator Locust 2.47.0 (MIT লাইসেন্স), Python 3.12-এ। Locust-এর OpenTelemetry রপ্তানি ডিফল্টে বন্ধ, তাই কোনো তথ্য বাইরে যায়নি। সব ভার শুধু নিজের localhost-এ। Locust-এর log-এ যন্ত্রের নাম থাকে বলে সেই লাইনগুলো বাদ দেওয়া হয়েছে।

সংখ্যাগুলো কীভাবে পড়বেন: app আর load generator একই ল্যাপটপে চলেছে, আর একই সময়ে কম্পিউটারে অন্য কাজও চলছিল। তাই এখানকার req/s বা ms production-এর ক্ষমতা নয়; এরা আকার আর তুলনা দেখায়। প্রতিটি তুলনা পরপর চালানো দুটি run-এর মধ্যে, একই load-এ। প্রতিটি run সর্বোচ্চ ২ মিনিট আর ১০০ জন ব্যবহারকারী, যাতে যন্ত্রের ওপর চাপ সীমিত থাকে।

Locust-এর বিস্তারিত (User class, task-এর ওজন, headless চালানো, CSV) পর্ব ৪৭-এ (Locust দিয়ে load test) দেখেছেন। এখানে একটি সরল সেল-দিনের journey: search, পণ্যের API, পণ্যের পাতা আর home, ওজন ৪:৩:২:১, প্রতিটি কাজের পরে ০.৫–১.৫ সেকেন্ড think time (Stress-এর run-গুলোতে THINK=off দিয়ে think time শূন্য)।

import os
import random

from locust import FastHttpUser, between, constant, task

THINK = os.environ.get("THINK", "on")
TERMS = ["oil", "চাল", "dal", "tea", "egg"]


class SaleDayShopper(FastHttpUser):
    """Sale-day browsing journey (read-only) on বাজারঘর."""
    wait_time = between(0.5, 1.5) if THINK == "on" else constant(0)

    @task(4)
    def search(self):
        self.client.get(f"/api/products?q={random.choice(TERMS)}",
                        name="/api/products?q=")

    @task(3)
    def product_api(self):
        self.client.get(f"/api/products/{random.randint(1, 12)}",
                        name="/api/products/{id}")

    @task(2)
    def product_page(self):
        self.client.get(f"/products/{random.randint(1, 12)}",
                        name="/products/{id}")

    @task(1)
    def home(self):
        self.client.get("/", name="/")

এবার gate. একটি performance quality gate-এর দুটি আলাদা প্রশ্ন: (১) পরম লক্ষ্য: search-এর p95 ৩০০ ms-এর মধ্যে আর error ১%-এর কম কি না; (২) আপেক্ষিক তুলনা: আগের ভালো build-এর (baseline) চেয়ে খারাপ হলো কি না। দ্বিতীয় প্রশ্নটি জরুরি, কারণ ৩০০ ms-এর সীমার অনেক নিচে থাকা একটি app প্রতিটি release-এ একটু একটু ধীর হতে পারে; সীমা ভাঙার দিন সবাই অবাক হন, অথচ performance regression জমছিল মাসের পর মাস।

"""CI perf gate: python perf_gate.py out/RUN_stats.csv baseline.json"""
import csv, json, sys

SLO = {"name": "/api/products?q=", "p95_ms": 300, "max_error_rate": 0.01}
TOL_PCT, TOL_MS = 20, 15            # allowed growth vs baseline (both must be exceeded)

row = next(r for r in csv.DictReader(open(sys.argv[1]))
           if r["Name"] == SLO["name"])
p95 = float(row["95%"])
errors = int(row["Failure Count"]) / int(row["Request Count"])
base = json.load(open(sys.argv[2]))["p95_ms"]

problems = []
if p95 > SLO["p95_ms"]:
    problems.append(f"SLO: p95 {p95:.0f} ms > {SLO['p95_ms']} ms")
if errors > SLO["max_error_rate"]:
    problems.append(f"SLO: error rate {errors:.2%} > {SLO['max_error_rate']:.0%}")
grow = p95 - base
if grow > TOL_MS and grow > base * TOL_PCT / 100:
    problems.append(f"REGRESSION: p95 {base:.0f} -> {p95:.0f} ms (+{grow:.0f} ms)")

print(f"{SLO['name']}  requests={row['Request Count']}  p95={p95:.0f} ms  "
      f"errors={errors:.2%}  baseline_p95={base:.0f} ms")
for p in problems:
    print("FAIL", p)
print("GATE", "FAILED" if problems else "PASSED")
sys.exit(1 if problems else 0)

চারটি build, প্রতিটিতে একই ভার: ৫০ জন ব্যবহারকারী (NFR-2-এর সংখ্যা), think time চালু, ৪৫ সেকেন্ড, এক worker. প্রথম দুটি একই পরিষ্কার build, পরপর দুবার; তৃতীয়টিতে বসানো ভুল slow_search চালু, কিন্তু BAZARGHAR_SLOW_MS=60, অর্থাৎ search-এ মাত্র ৬০ ms-এর বাড়তি দেরি; চতুর্থটিতে একই ভুল ডিফল্ট ১৫০০ ms-এ। প্রথম run-এর search-এর p95 (২১ ms) baseline.json-এ রাখা হলো। সত্যিকারের ফল:

$ python perf_gate.py out/g2_stats.csv baseline.json      # same clean build, run 2
/api/products?q=  requests=850  p95=26 ms  errors=0.00%  baseline_p95=21 ms
GATE PASSED
exit=0

$ python perf_gate.py out/g3_stats.csv baseline.json      # slow_search, 60 ms
/api/products?q=  requests=842  p95=81 ms  errors=0.00%  baseline_p95=21 ms
FAIL REGRESSION: p95 21 -> 81 ms (+60 ms)
GATE FAILED
exit=1

$ python perf_gate.py out/g4_stats.csv baseline.json      # slow_search, 1500 ms
/api/products?q=  requests=501  p95=1500 ms  errors=0.00%  baseline_p95=21 ms
FAIL SLO: p95 1500 ms > 300 ms
FAIL REGRESSION: p95 21 -> 1500 ms (+1479 ms)
GATE FAILED
exit=1

তিনটি ফল তিন রকম শিক্ষা দেয়। দ্বিতীয় run: কোডের একটি অক্ষরও বদলায়নি, তবু p95 ২১ থেকে ২৬ ms, অর্থাৎ প্রায় ২৪% বেশি। এটি noise: একই ল্যাপটপে অন্য কাজ, CPU-র গতি বদল, ছোট নমুনায় percentile-এর ওঠানামা। শুধু শতাংশের সীমা (২০%) থাকলে gate মিথ্যা লাল দিত। তাই নিয়মে দুটি শর্ত: বৃদ্ধি ২০%-এর বেশি এবং ১৫ ms-এর বেশি হলে তবেই regression; এই ধরনের সীমাকে বলে regression tolerance. তৃতীয় run: p95 ৮১ ms, SLO-র (৩০০) অনেক নিচে, কিন্তু baseline থেকে +৬০ ms; gate ধরল, exit code 1. শুধু SLO দেখলে এই ধীরতা চুপচাপ ঢুকে যেত। চতুর্থ run: দুটি শর্তই ভাঙল; আর request-এর সংখ্যা ৫০১, আগের চেয়ে অনেক কম, কারণ প্রতিটি ব্যবহারকারী ধীর উত্তরের জন্য অপেক্ষা করছিলেন (closed model, পর্ব ৪৬)।

Noise সামলানোর আরও কয়েকটি অভ্যাস flaky test-এর গণিতের সাথে মেলে (পর্ব ৪০): baseline আর নতুন build একই যন্ত্রে পরপর চালানো, কয়েকটি run-এর মধ্যমা নেওয়া, আর লাল হলে আবার চালানোর আগে দেখা পার্থক্য noise-এর পরিসরের বাইরে কি না। CI pipeline-এ gate কোন ধাপে বসবে, তা পর্ব ৬৪-এর (CI-তে test pipeline) বিষয়।

৪ · Utilisation আর latency — কেন ৯০% ব্যস্ত মানে বিপদ

মুদি দোকানে একজন বিক্রেতা, ক্রেতা আসেন এলোমেলোভাবে। দোকান যখন অর্ধেক সময় ফাঁকা থাকে, নতুন ক্রেতা প্রায় কখনো লাইনে দাঁড়ান না। দোকান ৯০% সময় ব্যস্ত হলে কয়েকজন একসাথে এলেই লাইন জমে, আর ফাঁকা মুহূর্ত কম বলে তা সরতে দেরি হয়। ব্যস্ততা ৫০% থেকে ৯০% হলো মানে কাজ ১.৮ গুণ, কিন্তু অপেক্ষা বাড়ে তার অনেক বেশি।

Queueing theory-র সবচেয়ে সরল মডেল M/M/1 এই আচরণ সূত্রে বলে। এলোমেলো (Poisson) আগমন, এলোমেলো সেবার সময় (গড় S), একজন সেবাদাতা, আর ব্যস্ততা ρ (utilisation) হলে গড় response time হয় S/(১ − ρ), আর response time-এর বণ্টন exponential বলে p95 = ln(২০) × S/(১ − ρ)। ব্লকটি সূত্রের পাশাপাশি একটি সত্যিকারের simulation চালায়: ৬০,০০০ request, প্রতিটি আসে, দরকার হলে অপেক্ষা করে, সেবা পায়। S = ১.৩ ms নেওয়া হয়েছে, কারণ পরের অংশের stress run-এ এক worker প্রায় ৭৫০ req/s-এ আটকেছিল, অর্থাৎ প্রতি request-এ মোটামুটি ১.৩ ms.

import math, random

random.seed(50)
S = 1.3                          # mean service time in ms (one worker)
MU = 1 / S                       # requests per ms the worker can finish

def simulate(rho, n=60_000):
    lam, t, free_at, times = rho * MU, 0.0, 0.0, []
    for _ in range(n):
        t += random.expovariate(lam)          # next arrival (open model)
        start = max(t, free_at)               # wait if the worker is busy
        free_at = start + random.expovariate(MU)
        times.append(free_at - t)             # response = wait + service
    times.sort()
    return times[int(0.95 * n)]

print(" rho  formula_p95  simulated_p95   bar")
for rho in (0.3, 0.5, 0.7, 0.8, 0.9, 0.95):
    formula = math.log(20) * S / (1 - rho)   # M/M/1: p95 = ln(20)/(mu - lambda)
    sim = simulate(rho)
    print(f"{rho:4.2f} {formula:9.1f} ms {sim:11.1f} ms   " + "#" * round(sim / 4))

আসল আউটপুট:

 rho  formula_p95  simulated_p95   bar
0.30       5.6 ms         5.6 ms   #
0.50       7.8 ms         7.6 ms   ##
0.70      13.0 ms        13.2 ms   ###
0.80      19.5 ms        19.9 ms   #####
0.90      38.9 ms        52.4 ms   #############
0.95      77.9 ms        75.0 ms   ###################

৩০% থেকে ৭০% ব্যস্ততায় p95 মাত্র ৫.৬ থেকে ১৩ ms. তারপর curve বাঁকে: ৮০%-এ প্রায় ২০, ৯০%-এ প্রায় ৪০ (সূত্র) আর ৯৫%-এ প্রায় ৭৫–৭৮ ms. ৫০% থেকে ৯০%-এ সূত্রের p95 পাঁচ গুণ (১/০.৫ বনাম ১/০.১)। আরেকটি জিনিস দেখুন: ৯০%-এ simulation ৫২.৪, সূত্র ৩৮.৯. বেশি ব্যস্ততায় লাইন দীর্ঘ সময় ধরে জমে থাকে, তাই ৬০,০০০ request-এর নমুনাও ওঠানামা করে; ব্যস্ত system-এর মাপ শান্ত system-এর চেয়ে বেশি noisy. random.seed(50) বদলে চালালে ৯০%-এর সারিটিই সবচেয়ে বেশি নড়বে। এখান থেকে capacity planning-এর নিয়মটি আসে: latency-র SLO রক্ষা করতে প্রতিটি worker-কে ১০০% নয়, ৬০–৭০% ব্যস্ততার কাছে চালানো হয়।

10.50   7.8 ms  ##20.70  13.0 ms  ###30.80  19.5 ms  #####40.90  38.9 ms  ##########50.95  77.9 ms  ###################
M/M/1, S = 1.3 ms
ρ
1/(1−ρ)
p95 সূত্র
req/s
  1. ρ = ০.৫০. Worker অর্ধেক সময় ফাঁকা; বেশিরভাগ request এসে সরাসরি সেবা পায়। গুণক ১/(১ − ρ) = ২, p95 ৭.৮ ms, আর throughput প্রায় ৩৮৫ req/s (০.৫ ÷ ১.৩ ms).
  2. ρ = ০.৭০. কাজ ৪০% বেড়ে প্রায় ৫৩৮ req/s; গুণক ৩.৩, p95 ১৩ ms. বৃদ্ধি কাজের চেয়ে একটু বেশি, তবু শান্ত এলাকা।
  3. ρ = ০.৮০. মাত্র ১৪% বেশি কাজ (৬১৫ req/s), কিন্তু p95 ১৯.৫ ms, অর্থাৎ ৫০% বেশি। Curve এখানে বাঁকতে শুরু করেছে; অনেকে এই এলাকাকে “knee” বলেন।
  4. ρ = ০.৯০. আরও ১২.৫% কাজ, আর p95 দ্বিগুণ, প্রায় ৩৯ ms. এখানে একটি ছোট ধাক্কা, যেমন একটি ধীর query, লাইনকে অনেকক্ষণ লম্বা রাখে।
  5. ρ = ০.৯৫. মাত্র ৫.৬% বেশি কাজের জন্য p95 আবার দ্বিগুণ, প্রায় ৭৮ ms. ১০০%-এর কাছে গুণক অসীমের দিকে যায়: এই এলাকায় capacity-র পরিকল্পনা করা মানে SLO-র সাথে জুয়া।

বাস্তবের system পুরো M/M/1 নয়, তবু আকারটি টেকে। Little-এর সূত্র আর এই curve-এর আরও গণিত আছে ক্লাউড ও DevOps কোর্সের পর্ব ৬৮-এ আর সিস্টেম ডিজাইন কোর্সের পর্ব ০৪-এ। Tester-এর জন্য মূল কথা: প্রতিটি load test-এ throughput আর latency একসাথে দেখুন; throughput বাড়া থামলে আর latency বাড়তে থাকলে আপনি knee পেরিয়েছেন।

৫ · Scalability — এক worker বনাম দুই worker

দোকানে দ্বিতীয় একজন বিক্রেতা আনলে লাইন অর্ধেক হওয়ার কথা। সফটওয়্যারে এর নাম horizontal scaling: একই কাজের আরেকটি কপি যোগ করা। এখানে কপি মানে Uvicorn-এর আরেকটি worker process (--workers 2); আরেকটি পথ vertical scaling, অর্থাৎ একই যন্ত্রকে বড় করা। প্রশ্ন হলো, দ্বিগুণ worker দিলে ক্ষমতা কি সত্যিই দ্বিগুণ হয়? দুটি পরীক্ষা চালানো হলো, দুটিতেই think time শূন্য, যাতে app-এর সীমা দেখা যায়।

পরীক্ষা ১: পরিষ্কার build, CPU-র কাজ

৪০ জন ব্যবহারকারী, think time নেই, ৬০ সেকেন্ড; পুরো সেল-দিনের journey. পরপর দুটি run, প্রথমে দুই worker, তারপর এক worker:

Workerমোট requestreq/sp50p95error
14605676952 ms71 ms0
285729143224 ms60 ms0

Throughput বাড়ল ১.৮৬ গুণ, দ্বিগুণের কাছে; বাকিটা গেল একই ল্যাপটপে চলা load generator আর অন্য কাজের ভাগে। Closed model-এ Little-এর সূত্র মেলে: ৪০ ÷ ৭৬৯ ≈ ৫২ ms, ৪০ ÷ ১৪৩২ ≈ ২৮ ms, যা মাপা গড়ের কাছাকাছি। কিন্তু একটি অদ্ভুত জিনিস: দুই worker-এ p50 অর্ধেকের বেশি কমল (৫২ → ২৪), অথচ p95 সামান্য (৭১ → ৬০)। যেন কিছু request খুব দ্রুত, কিছু আগের মতোই ধীর। এর কারণ বুঝতে দ্বিতীয় পরীক্ষা।

পরীক্ষা ২: ধীর search আর thread pool

পর্ব ৪৬-এ দেখেছেন, বাজারঘরের endpoint-গুলো সাধারণ (sync) Python function, যা প্রতিটি worker-এর ভেতরে ৪০টি thread-এর একটি pool-এ চলে (anyio-র ডিফল্ট সীমা)। slow_search চালু থাকলে প্রতিটি search একটি thread ১.৫ সেকেন্ড আটকে রাখে। তাই এক worker-এর search-এর সর্বোচ্চ ক্ষমতা ৪০ ÷ ১.৫ ≈ ২৬.৭ req/s, আর ৪০ জনের বেশি একসাথে এলে বাকিরা লাইনে দাঁড়ায়। এবার ৬০ জন, সবাই শুধু search করেন, think time নেই, ৬০ সেকেন্ড:

WorkerConnectionreq/sp50p95
1keep-alive26.32000 ms3000 ms
1প্রতি request-এ নতুন26.41600 ms3000 ms
2keep-alive (৩টি run)29.8 / 35.6 / 34.61500–1600 ms2900–3000 ms
2প্রতি request-এ নতুন39.71500 ms1500 ms

এক worker-এ ফল সূত্রের সাথে মেলে: ২৬.৩ req/s, ২৬.৭-এর প্রায় সমান; ৬০ জনের ২০ জন প্রতিবার লাইনে, তাই অনেক request-এর সময় ১.৫ + ১.৫ = প্রায় ৩ সেকেন্ড। পর্ব ৪৬-এর মাপের সাথেও মেলে (৫০ জনে p95 প্রায় ২.৯ s). দুই worker-এ থাকে ৮০টি thread, তাই ৬০ জনের কারও অপেক্ষার কথা নয়। অথচ keep-alive-এ তিনবার চালিয়ে p95 থাকল প্রায় ৩ সেকেন্ড, আর throughput ৩০–৩৬, প্রত্যাশিত ৪০-এর নিচে, প্রতি run-এ আলাদা।

কারণ HTTP keep-alive. Locust-এর প্রতিটি ব্যবহারকারী একটি TCP connection খুলে রাখেন, আর যে worker সেই connection নেয়, তার সব request সেখানেই যায়। দুই worker একই port-এ connection নেয়, কিন্তু কে কতগুলো পাবে তা সমান হওয়ার নিশ্চয়তা নেই। কোনো worker ৪০-এর বেশি connection পেলে তার thread pool ভরে, লাইন জমে, আর অন্য worker-এর thread অলস থাকে। প্রমাণের জন্য একই ভার আবার চালানো হলো, এবার প্রতিটি request-এ নতুন connection (Connection: close header). প্রতিটি নতুন connection আবার দুই worker-এর মধ্যে ভাগ হয়, তাই ভার সমান হয়: p50, p75, p95 সবই ১৫০০ ms, throughput ৩৯.৭ req/s, যা ৬০ ÷ ১.৫ = ৪০-এর প্রায় সমান। Knee সত্যিই সরেছে, কিন্তু শুধু তখন, যখন ভার সমানভাবে ভাগ হয়। এক worker-এ connection-এর ধরন বদলে কিছু হয়নি (২৬.৪ req/s, p95 ৩ s), কারণ সেখানে ভাগ করার কেউ নেই।

মূল ধারণা

Scalability test-এ শুধু “worker বাড়ালে throughput কত বাড়ল” নয়, ভার কীভাবে ভাগ হলো সেটিও দেখুন। Production-এ এই ভাগ করে load balancer (সিস্টেম ডিজাইন কোর্সের পর্ব ১৪), কিন্তু দীর্ঘ connection সেখানেও অসম ভাগ তৈরি করে। আর দ্বিগুণ কপি দ্বিগুণ ক্ষমতা দেয় শুধু তখনই, যখন ভাগ করা কোনো সম্পদ, যেমন database-এর লেখার lock, নতুন bottleneck হয়ে না দাঁড়ায় (পর্ব ৪৯-এর বিষয়)।

৬ · Stress থেকে ভাঙন, তারপর ফিরে আসা

Load test প্রশ্ন করে, “প্রত্যাশিত ভারে লক্ষ্য রক্ষা পায় কি?” Stress test প্রশ্ন করে, “কোথায় ভাঙে, কীভাবে ভাঙে, আর চাপ সরলে ফিরে আসে কি?” প্রথম প্রশ্নের উত্তর দেয় breaking point; দ্বিতীয়টির উত্তর ভাঙনের ধরন: ধীরে ধীরে খারাপ হওয়া, না হঠাৎ পতন; তৃতীয়টির উত্তর recovery time. একটি LoadTestShape দিয়ে ধাপে ধাপে ভার বাড়ানো হলো: প্রতি ১০ সেকেন্ডে ১০ জন করে ১০ থেকে ১০০, তারপর হঠাৎ ১০ জনে নেমে ২০ সেকেন্ড; মোট ১২০ সেকেন্ড, think time নেই, এক worker, পরিষ্কার build.

from locust import LoadTestShape

from locustfile import SaleDayShopper  # noqa: F401  (THINK=off)


class StepThenRecover(LoadTestShape):
    """10 -> 100 users (+10 every 10 s), then back to 10 users."""
    def tick(self):
        t = self.get_run_time()
        if t < 100:
            users = 10 * (int(t // 10) + 1)
            return users, 100
        if t < 120:
            return 10, 100                 # load drops: does it recover?
        return None

Locust-এর --csv-full-history প্রতি সেকেন্ডের একটি সারি লেখে। একটি ছোট script প্রতিটি ধাপের প্রথম সেকেন্ড বাদ দিয়ে গড় req/s, ধাপের শেষের p95 (Locust-এর শেষ ১০ সেকেন্ডের জানালা) আর error গোনে। সত্যিকারের ফল:

phase    users  req/s   p95  errors
ramp       10    708    19    0.0%
ramp       20    712    39    0.0%
ramp       30    697    59    0.0%
ramp       40    747    72    0.0%
ramp       50    759    88    0.0%
ramp       60    760   100    0.0%
ramp       70    736   120    0.0%
ramp       80    750   140    0.0%
ramp       90    780   150    0.0%
ramp      100    778   170    0.0%
recover    10    734    18    0.0%

Stress run: ব্যবহারকারী বাড়ল, throughput আটকে রইল, p95 বাড়তে থাকল

Real run, one worker, app and load generator on the same laptop; two panels with separate scales

Throughput flat near 750 req/s from 10 users; p95 rises from 19 to 170 ms and crosses the 100 ms line after 60 users Throughput (req/s) p95 (ms) 0 500 1000 0 100 200 SLO-র সীমা 100 ms 708 778 19 170 104070100 104070100 একসাথে ব্যবহারকারী (think time শূন্য)
ছবি ৫০.১ — ওপরে throughput, নিচে p95; দুটির মাপ আলাদা বলে আলাদা প্যানেল। ১০ জনেই worker প্রায় পূর্ণ ব্যস্ত; এরপর প্রতিটি নতুন ব্যবহারকারী শুধু লাইন লম্বা করেন।

Curve-টি চতুর্থ অংশের গল্পই বলে, closed model-এর ভাষায়। ১০ জনেই throughput প্রায় ৭০০ req/s, আর ১০০ জনে ৭৭৮: worker প্রথম ধাপেই প্রায় পূর্ণ ব্যস্ত, তাই এর পরে আর কাজ বাড়ে না, শুধু অপেক্ষা বাড়ে। p95 প্রায় সরলরেখায় বাড়ে, প্রতি ১০ জনে কমবেশি ১৫–২০ ms, কারণ closed model-এ latency ≈ ব্যবহারকারী ÷ throughput. যদি অভ্যন্তরীণ লক্ষ্য হয় “p95 ≤ ১০০ ms”, তাহলে এই যন্ত্রে, এই journey-তে, এক worker-এর breaking point ৬০ থেকে ৭০ জনের মধ্যে: ৬০-এ ঠিক ১০০, ৭০-এ ১২০. কোনো error নেই, system থামেনি; এটি “ধীরে ধীরে খারাপ হওয়া” ধরনের ভাঙন। আর চাপ ১০ জনে নামতেই p95 ১৮ ms, অর্থাৎ ফিরে আসা প্রায় সঙ্গে সঙ্গে।

Closed model ভাঙন লুকায়: এখানে latency “মাত্র” ১৭০ ms, কারণ ১০০ জন ব্যবহারকারী উত্তর না পেয়ে নতুন request পাঠান না; ভার নিজে থেকে কমে আসে। বাস্তবের সেল-দিনে নতুন ক্রেতা আসতেই থাকেন (open model), আর ক্ষমতার বেশি আগমনে লাইন সীমাহীনভাবে বাড়ে। তাই closed-model-এর stress run-এর সংখ্যাকে ক্ষমতার সর্বোচ্চ সীমা ধরবেন না; open আর closed model-এর পার্থক্য আর coordinated omission পর্ব ৪৬ আর ৪৮-এ (k6 দিয়ে load test) দেখুন।

দ্বিতীয় রূপ: সীমা বসিয়ে ফিরিয়ে দেওয়া

Latency সীমাহীন বাড়তে দেওয়ার বদলে একটি server সীমার বাইরের request দ্রুত ফিরিয়ে দিতে পারে; একে admission control বা load shedding বলে (সিস্টেম ডিজাইন কোর্সের পর্ব ১৮)। Uvicorn-এর --limit-concurrency 60 দিয়ে একই stress run চালানো হলো। এই সীমার বাইরে Uvicorn HTTP 503 দেয়। সত্যিকারের ফল (একই script, একই ধাপ):

phase    users  req/s   p95  errors
ramp       40    740    75    0.0%
ramp       50    836    83    7.4%
ramp       60    996   110   31.8%
…
ramp      100   1347   110   46.1%
recover    10    720    19    0.0%

Error report (whole run: 105740 requests, 19483 failures)
14543  LocustBadStatusCode(code=503)
 4940  OSError(10048, '[WinError 10048] Only one usage of each socket
       address (protocol/network address/port) is normally permitted.')

এখানে ভাঙন অন্য রকম: ৫০ জনেই error শুরু, ১০০ জনে প্রায় অর্ধেক request ব্যর্থ। req/s-এর সংখ্যা বেড়েছে, কিন্তু সেটি সাফল্য নয়; ব্যর্থ request দ্রুত ফেরে বলে সংখ্যায় বেশি। সীমা ৬০ হলেও error এসেছে ৫০ জনেই; নথির সংখ্যা আর আসল আচরণ মিলিয়ে দেখা tester-এর কাজ। আর error report-এ দুই ধরনের ব্যর্থতা আছে, যা আলাদা করা জরুরি। ১৪,৫৪৩টি 503 এসেছে server থেকে: এটি নকশা করা আচরণ। কিন্তু ৪,৯৪০টি WinError 10048 এসেছে load generator-এর দিক থেকে: 503-এর পরে connection বন্ধ হয়, Locust নতুন connection খোলে, আর এত দ্রুত খোলা-বন্ধে Windows-এর অস্থায়ী client port (ephemeral port) সাময়িকভাবে ফুরিয়ে যায়। এগুলো app-এর ব্যর্থতা নয়, মাপার যন্ত্রের। রিপোর্টে এদের app-এর error-এর সাথে যোগ করলে সিদ্ধান্ত ভুল হবে।

ফিরে আসাটি প্রতি সেকেন্ডের সারিতে স্পষ্ট: চাপ ১০ জনে নামার পরের সেকেন্ড থেকেই error শূন্য, আর Locust-এর ১০ সেকেন্ডের জানালার p95 প্রায় দশ সেকেন্ডে ১০০ থেকে ১৯-২০ ms-এ নামল। খেয়াল করুন, মাপার যন্ত্রের নিজের জানালাও ফিরে আসাকে লম্বা দেখাতে পারে। বাস্তবের system-এ ফিরে আসা সবসময় এত দ্রুত হয় না: জমে থাকা queue, retry-এর ঝড় বা ঠান্ডা cache মিনিটের পর মিনিট টানতে পারে। ইচ্ছাকৃত বিকল ঘটিয়ে recovery যাচাই পর্ব ৫৭ (Compatibility আর reliability) আর ৬৩-এর (Chaos আর resilience testing) বিষয়।

৭ · Soak — ধীরে জমে এমন সমস্যা (ছোট করা run)

কিছু সমস্যা দশ মিনিটে দেখা যায় না, দশ ঘণ্টায় দেখা যায়: memory leak, প্রতিটি request-এ একটু করে বাড়া cache, বন্ধ না হওয়া connection বা ফাইল (resource leak), দিনের শেষে বড় হয়ে যাওয়া log-এর টেবিল। এগুলো খোঁজে soak (বা endurance) test: মাঝারি, স্বাভাবিক ভার দীর্ঘ সময় ধরে, আর পাশে প্রতিটি সম্পদের প্রবণতা। বাস্তবে soak চলে কয়েক ঘণ্টা থেকে এক রাত। এই পর্বে যন্ত্রের সীমার কারণে একটি ছোট করা soak চালানো হলো: মাত্র ৪ মিনিট, ৩০ জন ব্যবহারকারী, think time চালু, এক worker; পাশে একটি script প্রতি ৩০ সেকেন্ডে app process-এর memory (Windows-এর working set) পড়েছে।

t(s)  app memory (MB)
   0    50.8
  30    56.4
  60    56.3
  90    56.4
 120    56.4
 150    56.4
 181    56.5
 211    56.4
 241    56.5  (load stopped)
minute  p95(ms)  total requests  failures
     1       23            1787         0
     2       18            3544         0
     3       21            5333         0
     4       17            7111         0

প্রথম ৩০ সেকেন্ডে memory ৫০.৮ থেকে ৫৬.৪ MB: এটি স্বাভাবিক গরম হওয়া (thread pool-এর thread, template-এর cache, database connection). তারপর সাড়ে তিন মিনিট সমতল, ৫৬.৩–৫৬.৫. p95 প্রতি মিনিটে ১৭–২৩ ms, ৭,১১১ request-এ একটিও ব্যর্থ নয়। এই ছোট run-এর সৎ সিদ্ধান্ত: ৪ মিনিটে কোনো leak-এর লক্ষণ দেখা যায়নি, “leak নেই” নয়। প্রতি ঘণ্টায় কয়েক MB বাড়ে এমন leak এই run-এ ধরা পড়ার কথা না। Soak-এর ফল বিচারের তিনটি নিয়ম মনে রাখুন। এক, গরম হওয়ার সময় বাদ দিয়ে প্রবণতা দেখুন। দুই, একটি সংখ্যা নয়, সরলরেখার ঢাল দেখুন: “প্রতি ঘণ্টায় কত MB”. তিন, শুধু memory নয়: খোলা ফাইল, connection, disk আর response time-ও।

৮ · Capacity planning — ঈদের সেলের হিসাব

কোরবানির ঈদের আগে পশুর হাটের ইজারাদার শুধু গত সপ্তাহের ভিড় দেখে জায়গা ঠিক করেন না। তিনি জানেন হাটের শেষ দুই দিনে ভিড় কয়েক গুণ হয়; গত বছরের অভিজ্ঞতা, এবারের প্রত্যাশা, আর একটি বাড়তি জায়গা, যদি কোনো অংশ বৃষ্টিতে ডুবে যায়। Capacity planning একই কাজ: চাহিদার পূর্বাভাস, মাপা ক্ষমতা, আর অনিশ্চয়তার জন্য বাড়তি জায়গা।

বাজারঘরের জন্য পাঁচটি উপাদান। (১) সাধারণ দিনের সবচেয়ে ব্যস্ত ঘণ্টার ভার। (২) সেল পর্যন্ত প্রবৃদ্ধি। (৩) peak factor: সেল-দিনের ভিড় সাধারণ peak-এর কত গুণ; এটি অনুমান, তাই একটি পরিসর ধরে হিসাব করুন। (৪) একটি worker-এর মাপা ক্ষমতা, যা আসে stress test থেকে, আর লক্ষ্য ব্যস্ততা (যেমন ৬০%), যাতে latency curve-এর শান্ত এলাকায় থাকা যায়; এই ফাঁকা অংশই headroom. (৫) N+1: একটি worker বিকল বা আপডেটে থাকলেও বাকিরা যেন পুরো ভার নেয়। নিচের সব সংখ্যা কাল্পনিক; worker-এর ক্ষমতা এখানে একটি staging stress test-এর ফল ধরা হয়েছে, ল্যাপটপের সংখ্যা নয়।

import math

# invented planning inputs for বাজারঘর (not real traffic)
normal_peak_rps = 60          # busiest hour of an ordinary evening
growth = 1.25                 # expected growth until the sale
sale_factor = 5.0             # Eid sale peak vs ordinary peak (assumption)
worker_max_rps = 120          # one worker's limit, from a staging stress test
target_util = 0.60            # keep each worker at most 60% busy -> p95 safe
spare = 1                     # N+1: one worker may die or be redeployed

for name, factor in (("ordinary day", 1.0), ("Eid sale", sale_factor)):
    peak = normal_peak_rps * growth * factor
    usable = worker_max_rps * target_util          # rps per worker at 60%
    need = math.ceil(peak / usable)
    total = need + spare
    util = peak / (total * worker_max_rps)
    print(f"{name:12}: peak={peak:5.0f} rps  usable/worker={usable:.0f}  "
          f"workers={need}+{spare}={total}  util={util:.0%}")

# what if the sale factor guess is wrong?
for f in (4, 5, 6, 8, 10):
    peak = normal_peak_rps * growth * f
    print(f"factor {f:>2}: peak {peak:5.0f} rps -> "
          f"{math.ceil(peak / (worker_max_rps * target_util)) + spare} workers")

আসল আউটপুট:

ordinary day: peak=   75 rps  usable/worker=72  workers=2+1=3  util=21%
Eid sale    : peak=  375 rps  usable/worker=72  workers=6+1=7  util=45%
factor  4: peak   300 rps -> 6 workers
factor  5: peak   375 rps -> 7 workers
factor  6: peak   450 rps -> 8 workers
factor  8: peak   600 rps -> 10 workers
factor 10: peak   750 rps -> 12 workers

সাধারণ দিনে ৩টি worker (২টি দরকার, ১টি বাড়তি), সেল-দিনে ৭টি. সেল-দিনে সব ৭টি চললে প্রতিটির ব্যস্ততা ৪৫%; একটি বিকল হলে বাকি ৬টিতে ৩৭৫ ÷ ৭২০ ≈ ৫২%, তখনও ৬০%-এর নিচে, এটাই N+1-এর উদ্দেশ্য। শেষ পাঁচ লাইন পরিকল্পনার সবচেয়ে সৎ অংশ: peak factor ৫-এর বদলে ৮ হলে ১০টি worker লাগবে। তাই পরিকল্পনা একটি সংখ্যা নয়, একটি পরিসর, আর সেলের আগে load test চালানো হয় পরিসরের ওপরের প্রান্তে, যেমন factor ৮-এর ভারে। এবার target_util ০.৮০ করে দেখুন worker কমে কত; চতুর্থ অংশের curve মনে রাখলে বুঝবেন কেন সেই সাশ্রয় ঝুঁকিপূর্ণ।

1normal_peak = 60 rps2× growth 1.25  → 753× sale 5.0     → 3754usable = 120 × 0.60 = 725ceil(375 / 72) = 666 + 1 spare = 7 workers
পরিকল্পনা (কাল্পনিক)
peak
usable/worker
workers
ব্যস্ততা
  1. ভিত্তি। সাধারণ দিনের সবচেয়ে ব্যস্ত ঘণ্টায় ৬০ req/s. এটি মাপা সংখ্যা হওয়া উচিত, production-এর metric থেকে; গড় দিনের নয়, ব্যস্ততম ঘণ্টার।
  2. প্রবৃদ্ধি। সেল পর্যন্ত ব্যবহারকারী ২৫% বাড়বে বলে অনুমান: ৬০ × ১.২৫ = ৭৫ req/s.
  3. Peak factor. ঈদের সেলের ভিড় সাধারণ peak-এর ৫ গুণ ধরে ৩৭৫ req/s. এটি সবচেয়ে অনিশ্চিত সংখ্যা; গত সেলের data না থাকলে পরিসর ধরুন।
  4. Worker-প্রতি ব্যবহারযোগ্য ক্ষমতা। Stress test বলেছে একটি worker সর্বোচ্চ ১২০ req/s; latency রক্ষায় ৬০%-এর বেশি নয়, তাই ৭২ req/s. বাকি ৪০% হলো headroom.
  5. প্রয়োজনীয় সংখ্যা। ৩৭৫ ÷ ৭২ = ৫.২১, ওপরে গোল করে ৬টি worker. ৬টিতে ব্যবহারযোগ্য ক্ষমতা ৪৩২, তার ৮৭% ভরবে।
  6. N+1. একটি বাড়তি, মোট ৭টি. সব চললে ব্যস্ততা ৩৭৫ ÷ ৮৪০ ≈ ৪৫%; একটি বিকল হলেও ৬টিতে প্রায় ৫২%, সীমার ভেতরে।

Autoscaling কি এই হিসাব অপ্রয়োজনীয় করে?

Autoscaling ভার দেখে কপির সংখ্যা নিজে বাড়ায়-কমায় (ক্লাউড ও DevOps কোর্সের পর্ব ১৭)। কিন্তু দুটি কারণে capacity plan তবু দরকার। এক, দেরি: metric জমা, সিদ্ধান্ত, নতুন কপি চালু আর গরম হতে সময় লাগে; সেলের প্রথম মিনিটের ঢেউ তার আগেই আসে। দুই, সীমা: app-এর কপি বাড়ানো যায়, কিন্তু database, payment gateway বা কোনো অংশীদারের API একই হারে বাড়ে না; ১০টি worker একটি database-এ ১০ গুণ চাপ দেয়। তাই সেলের আগে autoscaling-সহ পুরো ব্যবস্থায় একটি spike test দরকার: নতুন কপি আসার আগের মিনিটগুলোতে SLO টেকে কি না; আর প্রয়োজনে আগে থেকেই কপি বাড়িয়ে রাখা, যাকে pre-scaling বলে।

হিসাব ভুল প্রমাণিত হলে কাজে আসে graceful degradation: কম জরুরি অংশ বন্ধ রেখে search, কার্ট আর checkout চালু রাখা। এই সুইচগুলো কাজ করে কি না, সেটিও সেলের আগে test করার বিষয়।

আরও গভীরে: M/M/1 একজন সেবাদাতার মডেল; একাধিক worker-এর জন্য M/M/c (Erlang C) মডেল আছে, যা দেখায় একই মোট ব্যস্ততায় একটি বড় লাইন অনেক ছোট লাইনের চেয়ে কম অপেক্ষা দেয়, আর keep-alive-এর অসম ভাগ কেন ক্ষতিকর। Neil Gunther-এর Universal Scalability Law (১৯৯০-এর দশকে প্রস্তাবিত বলে উল্লেখ করা হয়) কপি বাড়ালে throughput কেন সরলরেখায় বাড়ে না তার দুটি কারণ আলাদা করে: ভাগ করা সম্পদের জন্য লড়াই আর কপিদের মধ্যে সমন্বয়ের খরচ; কয়েকটি মাপা বিন্দু থেকে এর দুটি সহগ বের করে বড় স্কেলে পূর্বাভাস করা যায়, সাবধানে। Performance regression ধরতে বড় দলগুলো একটি run-এর বদলে অনেক run-এর বণ্টন তুলনা করে, পরিসংখ্যানের পরীক্ষা বা change-point detection দিয়ে, আর আলাদা, শান্ত যন্ত্রে benchmark চালায়।

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

  • SLI, SLO আর SLA-র পার্থক্য? SLI মাপা অনুপাত, SLO তার লক্ষ্য একটি সময়ের জানালাসহ, SLA পরিণতিসহ চুক্তি; SLO সাধারণত SLA-র চেয়ে কড়া।
  • ৯৯.৯% SLO-তে ৩০ দিনে কত খারাপ সময় চলে? ০.১% × ৩০ × ২৪ × ৬০ = ৪৩.২ মিনিট।
  • Utilisation ৮০% থেকে ৯০% হলে M/M/1-এ গড় response time কত গুণ? ১/(১ − ρ): ৫ থেকে ১০, অর্থাৎ দ্বিগুণ।
  • Performance gate শুধু SLO দেখলে কী মিস হয়? SLO-র নিচে থাকা ধীর অবনতি; তাই baseline-এর সাথে noise-সহ তুলনাও লাগে।
  • Soak test কী খোঁজে? সময়ের সাথে জমে এমন সমস্যা: memory বা connection leak, ধীরে বাড়া latency, ভরে যাওয়া disk.

৯ · AI-এর যুগে — AI দিয়ে SLO, load script আর capacity হিসাব

AI সহকারী কয়েক সেকেন্ডে একটি SLO নথি, একটি Locust script আর একটি capacity-র spreadsheet দিতে পারে। কিন্তু performance-এর ক্ষেত্রে তার চেনা ভুলগুলো বেশি বিপজ্জনক, কারণ ফল সংখ্যায় আসে আর সংখ্যা বিশ্বাসযোগ্য দেখায়। সাধারণ ভুল: SLO গড়ের ভাষায় বা জানালা ছাড়া; শুধু সুখী পথের (happy path) journey, error বা ধীর পথ বাদ; Locust বা k6-এর কল্পিত option; think time ছাড়া closed-model run থেকে “system ১০,০০০ ব্যবহারকারী সামলাবে” ধাঁচের সিদ্ধান্ত; একটি run থেকে regression দাবি, noise না দেখে; আর না চালিয়েই “test পাস করবে”. সবচেয়ে বিপজ্জনক: script-এর host-এ একটি আসল website-এর ঠিকানা বসানো, যা অনুমতি ছাড়া load test, অর্থাৎ আক্রমণের সমান।

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

তুমি একজন অভিজ্ঞ performance tester. বাজারঘরের search API-র জন্য Locust 2.x-এ একটি headless load test আর একটি CI gate script লিখবে। নিচে আমাদের SLO আর OpenAPI-র অংশ দিলাম। নিয়ম: ১. Host শুধু http://127.0.0.1:8825; অন্য কোনো ঠিকানা লিখবে না। ২. SLO: চলমান ২৮ দিনে ৯৯.৫% search ৩০০ ms-এর মধ্যে সফল। Gate-এ p95 ≤ 300 ms আর error ≤ 1%, আর baseline থেকে ২০% এবং ১৫ ms দুটোই ছাড়ালে regression. ৩. ব্যবহারকারী সর্বোচ্চ ৫০, সময় সর্বোচ্চ ৬০ সেকেন্ড, think time ০.৫–১.৫ সেকেন্ড। ৪. শুধু Locust-এর official নথিতে থাকা option আর CSV কলামের নাম ব্যবহার করবে; প্রতিটির নাম নথির কোন অংশে আছে বলবে। ৫. Gate-কে exit code দিয়ে ফল জানাতে হবে; কোনো সংখ্যা অনুমান করে লিখবে না। ৬. তুমি কিছু চালাওনি; "পাস করবে" বা "এত req/s হবে" দাবি করবে না। [এখানে SLO আর OpenAPI-র অংশ]

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

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

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

প্র ০১১০০% availability বা “কখনো ধীর নয়” কেন একটি ভুল SLO, আর error budget কীভাবে দলের সিদ্ধান্ত বদলায়?

প্রথম শুনলে ১০০% লক্ষ্যই দায়িত্বশীল মনে হয়: ব্যবহারকারী তো সবসময় ভালো সেবা চান। কিন্তু “Site Reliability Engineering” বই (২০১৬) আর তার পরের “The Site Reliability Workbook” (২০১৮) এই ধারণার বিরুদ্ধে কয়েকটি যুক্তি জনপ্রিয় করে। প্রথমত, ব্যবহারকারী আর আপনার server-এর মাঝে মোবাইল নেটওয়ার্ক, Wi-Fi, ফোনের ব্যাটারি সাশ্রয়ের মোড আর লোডশেডিং আছে; সেগুলো নিজেরাই ১০০% নয়। আপনার দিকের ৯৯.৯৯% আর ১০০%-এর পার্থক্য ক্রেতা প্রায় টের পান না, অথচ সেই শেষ ধাপের খরচ বিশাল।

দ্বিতীয়ত, ১০০% লক্ষ্যের মানে কোনো পরিবর্তনই ঝুঁকি নিতে পারবে না। প্রতিটি deploy, প্রতিটি নতুন feature, database-এর প্রতিটি migration কিছু ঝুঁকি আনে। লক্ষ্য ১০০% হলে যুক্তিসঙ্গত পথ একটাই: কিছু না বদলানো। বাস্তবে দলগুলো তখন লক্ষ্যটি চুপচাপ ভাঙে, আর তার ওপর আস্থা চলে যায়।

Error budget এই টানাপোড়েনকে একটি সংখ্যায় আনে। ৯৯.৫% লক্ষ্য মানে ০.৫% খারাপ অনুমোদিত, আর সেটি খরচ করা যায়: দ্রুত release, পরীক্ষামূলক feature, পরিকল্পিত রক্ষণাবেক্ষণে। বাজেট বাকি থাকলে পণ্য দল গতি বাড়াতে পারে; ফুরিয়ে গেলে নিয়ম অনুযায়ী নতুন ঝুঁকি থামে, আর সময় যায় স্থিরতায়। তর্ক তখন “কে বেশি সাবধান” নিয়ে নয়, একটি মাপা সংখ্যা নিয়ে।

Tester-এর জন্য এর অর্থ দুটি। এক, release-এর আগের performance test-এর ভার আর সীমা এই বাজেট থেকে আসে; এই পর্বের হিসাবে দেখেছেন সেল-সপ্তাহে একই error-এর হারে বাজেট শেষ হয়ে যায়। দুই, বাজেট কম থাকলে test-এর কড়াকড়িও বাড়ে: বেশি ভার, বেশি সময়, বেশি পথ। SLO তাই শুধু operations-এর বিষয় নয়, test strategy-র একটি ইনপুট।

মূল উপলব্ধি: ১০০% লক্ষ্য পরিবর্তনকে নিষিদ্ধ করে আর শেষে বিশ্বাস হারায়; একটি সৎ SLO আর তার error budget ঝুঁকিকে মাপা সম্পদ বানায়, যা দিয়ে গতি আর স্থিরতার মধ্যে সিদ্ধান্ত নেওয়া যায়।

প্র ০২একটি server গড়ে মাত্র ৬০% ব্যস্ত, তবু সেল-দিনে p95 SLO ভাঙল। Queueing theory-র ইতিহাস আর মডেল এটি কীভাবে ব্যাখ্যা করে?

Queueing theory-র জন্ম টেলিফোনের লাইন থেকে। বিশ শতকের শুরুর দিকে কোপেনহেগেনের টেলিফোন কোম্পানিতে কাজ করা ডেনিশ গণিতবিদ A. K. Erlang প্রশ্ন করেছিলেন: কতগুলো লাইন থাকলে ব্যস্ত সংকেত পাওয়া কলের ভাগ একটি সীমার নিচে থাকবে? তাঁর কাজ (মোটামুটি ১৯০৯ থেকে ১৯১৭ সালের মধ্যে প্রকাশিত বলে উল্লেখ করা হয়) থেকেই এলোমেলো আগমন আর সেবার সময়ের গণিত দাঁড়ায়। পরে ১৯৫০-এর দশকে David Kendall লাইনের মডেলের সংক্ষিপ্ত নাম দেওয়ার পদ্ধতি দেন, যেখান থেকে “M/M/1” লেখার রীতি; আর ১৯৬১ সালে John Little তাঁর সূত্রের (লাইনে গড় সংখ্যা = আগমনের হার × গড় সময়) সাধারণ প্রমাণ প্রকাশ করেন।

এই মডেলের মূল শিক্ষা হলো, latency গড় ব্যস্ততার নয়, ব্যস্ততার বণ্টনের ওপর নির্ভর করে। “গড়ে ৬০%” কথাটি সাধারণত পাঁচ মিনিট বা এক ঘণ্টার গড়। সেল-দিনে ভার আসে ঢেউয়ে: একটি push notification, একটি Facebook পোস্ট, রাত বারোটায় অফার শুরু। পাঁচ মিনিটের গড় ৬০% হলেও কয়েক সেকেন্ডের জন্য ব্যস্ততা ৯৫% বা তার বেশি হতে পারে, আর এই পর্বের M/M/1 হিসাবে ৯৫%-এ p95 ৬০%-এর তুলনায় আট গুণের মতো। সেই কয়েক সেকেন্ডে আসা সব request p95-এর ভেতরে গোনা হয়।

দ্বিতীয় কারণ সেবার সময়ের বৈচিত্র্য। M/M/1 ধরে নেয় সেবার সময় exponential; বাস্তবে কিছু request (যেমন বড় search বা cache miss) অনেক বেশি সময় নেয়, আর এই লম্বা লেজ লাইনের সবাইকে আটকায়। Pollaczek-Khinchine-এর সূত্র (M/G/1) দেখায়, একই গড়ে সেবার সময়ের বৈচিত্র্য বাড়লে অপেক্ষাও বাড়ে। তৃতীয় কারণ এই পর্বের দুই worker-এর পরীক্ষা: মোট ব্যস্ততা মাঝারি হলেও ভার অসমভাবে ভাগ হলে একটি worker ভরে থাকে, যেখানে অন্যটি অলস।

তাই capacity-র লক্ষ্য ব্যস্ততা ৬০–৭০% রাখা হয় শুধু ভবিষ্যতের প্রবৃদ্ধির জন্য নয়, ঢেউ আর বৈচিত্র্যের জন্যও।

মূল উপলব্ধি: লাইন জমে মুহূর্তের ব্যস্ততায়, ঘণ্টার গড়ে নয়; ঢেউ, লম্বা লেজ আর অসম ভাগ মিলে “গড়ে ৬০%” system-কেও কয়েক সেকেন্ডের জন্য curve-এর খাড়া অংশে ঠেলে দেয়।

প্র ০৩Worker বা server দ্বিগুণ করলে ক্ষমতা কেন প্রায় কখনো ঠিক দ্বিগুণ হয় না? Amdahl থেকে আজকের system পর্যন্ত ভাবুন।

১৯৬৭ সালে Gene Amdahl একটি সম্মেলনে যুক্তি দেন যে একটি কাজের যে অংশ সমান্তরালে চালানো যায় না, সেটিই মোট গতিবৃদ্ধির সীমা ঠিক করে। কাজের ১০% যদি একটানা (serial) হয়, তাহলে যত processor-ই দিন, গতি দশ গুণের বেশি হবে না। পরে এই যুক্তিকে Amdahl's law নামে সূত্রের রূপ দেওয়া হয়। Web system-এ “serial অংশ” হলো ভাগ করা সম্পদ: একটি database-এর লেখার lock, একটি global counter, একটি একক cache server, বা একটি payment gateway-এর সীমা।

Neil Gunther-এর Universal Scalability Law আরেকটি কারণ যোগ করে: কপিদের মধ্যে সমন্বয়ের খরচ, যেমন cache মেলানো বা lock নিয়ে আলোচনা, যা কপির সংখ্যার সাথে বর্গের হারে বাড়তে পারে। এর ফলে একটি বিন্দুর পরে কপি বাড়ালে throughput কমে যেতেও পারে। এই কারণেই capacity planning-এ কয়েকটি মাপা বিন্দু (১, ২, ৪ কপি) লাগে, একটি নয়।

এই পর্বের run দুটি বাস্তব কারণ দেখিয়েছে, যা কোনো সূত্রে নেই। পরিষ্কার build-এ দুই worker throughput ১.৮৬ গুণ করল, কারণ load generator আর app একই ল্যাপটপের CPU ভাগ করছিল; মাপার যন্ত্র নিজেই সীমার অংশ হয়ে গেল। আর ধীর search-এর পরীক্ষায় keep-alive connection-এর অসম ভাগ দ্বিতীয় worker-এর সুবিধা প্রায় নষ্ট করল; প্রতি request-এ নতুন connection দিতেই p95 ৩ s থেকে ১.৫ s.

Tester-এর জন্য ব্যবহারিক নিয়ম: scalability test-এ শুধু শেষের throughput নয়, প্রতিটি কপির ভার আর ভাগ করা সম্পদের ব্যস্ততা মাপুন; load generator যেন নিজে সীমা না হয় (আলাদা যন্ত্র বা পর্যাপ্ত ক্ষমতা); আর “দ্বিগুণ কপি, কত গুণ ক্ষমতা” অনুপাতটি রিপোর্টে লিখুন। অনুপাত ২-এর অনেক নিচে হলে সেটিই পরের bottleneck-এর খোঁজের শুরু (পর্ব ৪৯)।

মূল উপলব্ধি: কপি বাড়ালে ক্ষমতা বাড়ে ভাগ না করা অংশের অনুপাতে; serial অংশ, সমন্বয়ের খরচ, অসম ভাগ আর মাপার যন্ত্রের নিজের সীমা মিলে দ্বিগুণকে কম করে।

প্র ০৪CI-র performance gate প্রায়ই flaky হয়: কখনো মিথ্যা লাল, কখনো আসল ধীরতা মিস। Noise আর সংকেত আলাদা করার নকশা কেমন হওয়া উচিত?

Functional test-এর flakiness (পর্ব ৪০) সাধারণত একটি bug: ভুল অপেক্ষা, ভাগ করা অবস্থা। Performance test-এর noise বেশিরভাগ ক্ষেত্রে bug নয়, প্রকৃতি। একই যন্ত্রে অন্য process, CPU-র গতির ওঠানামা, operating system-এর cache, garbage collection, আর নমুনার এলোমেলোতা মিলে একই কোড দুবার চালালে ভিন্ন সংখ্যা দেয়। এই পর্বে কোড না বদলেই p95 ২১ থেকে ২৬ ms হয়েছে, প্রায় ২৪%. M/M/1-এর simulation-এ দেখেছেন, বেশি ব্যস্ততায় noise আরও বাড়ে।

তাই gate-এর নকশায় কয়েকটি সিদ্ধান্ত জরুরি। প্রথম, দুই ধরনের সীমা: শতাংশ আর পরম মান দুটোই ছাড়ালে তবে regression; ছোট সংখ্যায় শতাংশ বিভ্রান্ত করে, বড় সংখ্যায় পরম মান। দ্বিতীয়, পরপর চালানো: baseline-কে মাসের পুরোনো একটি সংখ্যা হিসেবে না রেখে, একই যন্ত্রে, একই সময়ে আগের build আর নতুন build চালানো, যাতে পরিবেশের পরিবর্তন দুজনকে সমান ছোঁয়। তৃতীয়, একাধিক run: কয়েকটি run-এর বণ্টন তুলনা, প্রয়োজনে পরিসংখ্যানের পরীক্ষা দিয়ে। চতুর্থ, শান্ত যন্ত্র: ভাগ করা CI runner-এ সূক্ষ্ম benchmark প্রায় অর্থহীন; বড় দলগুলো আলাদা, স্থির যন্ত্রে performance suite চালায়।

আরেকটি সূক্ষ্ম ঝুঁকি হলো ধীরে জমা অবনতি: প্রতি build-এ ৩% ধীর, প্রতিবার tolerance-এর ভেতরে, আর baseline প্রতিবার নতুন build-এ সরে যায়। দশটি build পরে system ৩০%-এর বেশি ধীর, অথচ gate কখনো লাল হয়নি। প্রতিকার: baseline কেবল মানুষের অনুমোদনে সরানো, আর পাশাপাশি একটি স্থির “নোঙর” baseline (যেমন গত release) রাখা। আর SLO-র পরম সীমা সবসময় শেষ রক্ষাকবচ হিসেবে থাকে।

শেষে, gate লাল হলে প্রথম প্রতিক্রিয়া “আবার চালানো” নয়, যা flaky test-এর মতোই সমস্যা লুকায়। আগে প্রশ্ন: পার্থক্য noise-এর জানা পরিসরের বাইরে কি না, আর কোন endpoint-এ। এই পর্বের তৃতীয় build-এ +৬০ ms ছিল noise-এর (±৫ ms) বহু গুণ, আর শুধু search আর home-এ; সংকেত স্পষ্ট।

মূল উপলব্ধি: Performance-এর noise দূর করা যায় না, মাপা যায়; পরপর চালানো, দুই ধরনের সীমা, একাধিক run আর সরে না যাওয়া নোঙর-baseline মিলে gate-কে বিশ্বাসযোগ্য করে।

প্র ০৫সেল-দিনের capacity plan একটি ভবিষ্যদ্বাণী, আর ভবিষ্যদ্বাণী ভুল হয়। একজন tester কীভাবে পরিকল্পনাকে ভুলের বিরুদ্ধে শক্ত করতে পারেন?

প্রতিটি capacity plan-এর কেন্দ্রে একটি অনুমান: এবারের ভিড় কত হবে। পয়লা বৈশাখের অফার, ঈদের সেল বা একটি ভাইরাল ভিডিও, প্রতিটির ভিড়ের আকার আগে থেকে ঠিক জানা যায় না। এই পর্বের হিসাবে peak factor ৫ থেকে ৮ হলে worker ৭ থেকে ১০, প্রায় দেড় গুণ। তাই পরিকল্পনা একটি সংখ্যা নয়, একটি পরিসর, আর সিদ্ধান্তের প্রশ্ন হয়ে দাঁড়ায়: পরিসরের কোন প্রান্তের জন্য তৈরি থাকব, আর তার বাইরে গেলে কী করব।

Tester-এর প্রথম অবদান অনুমানগুলো লিখিত করা আর যাচাই করা। Worker-প্রতি ক্ষমতা কোন stress test থেকে এসেছে, কোন journey-তে, কোন data-র আকারে? সেল-দিনে ক্রেতারা কি একই journey করবেন, নাকি checkout অনেক বেশি, যা database-এ লেখার lock-এ চাপ দেয়? প্রতিটি অনুমানের পাশে একটি test থাকা উচিত: সেল-দিনের journey-র ওজন দিয়ে load test, পরিসরের ওপরের প্রান্তে।

দ্বিতীয় অবদান পরিসরের বাইরের আচরণ test করা: পরিকল্পনার চেয়ে বেশি ভারে system কীভাবে ভাঙে। এই পর্বে দেখেছেন দুটি ধরন: ধীরে ধীরে latency বাড়া, আর সীমা বসিয়ে দ্রুত 503. দ্বিতীয়টি ভালো, যদি ক্রেতা স্পষ্ট বার্তা পান আর চাপ সরলে system দ্রুত ফেরে। Load shedding, কম জরুরি feature বন্ধের সুইচ আর autoscaling-এর নিয়ম সেলের আগেই একটি spike test-এ চালিয়ে দেখা যায়।

তৃতীয় অবদান মহড়া। বড় অনলাইন ঘটনার আগে অনেক দল “game day” করে: পুরো দল উপস্থিত, পরিকল্পিত ভার, ইচ্ছাকৃত বিকল (একটি worker বন্ধ), আর dashboard-এ SLO দেখা (ক্লাউড ও DevOps কোর্সের পর্ব ৬৮)। এতে মানুষের প্রস্তুতিও যাচাই হয়। শেষে, সেলের পরে আসল data দিয়ে পরিকল্পনা মিলিয়ে দেখা, যাতে পরের বারের peak factor অনুমান নয়, মাপা সংখ্যা হয়।

মূল উপলব্ধি: ভুল পূর্বাভাস অনিবার্য; tester পরিকল্পনাকে শক্ত করেন অনুমান লিখে আর test করে, পরিসরের বাইরের ভাঙনকে নিয়ন্ত্রিত করে, আর সেলের আগে মহড়া ও পরে হিসাব মিলিয়ে।

অনুশীলন

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

  1. Spec থেকে performance test: বাজারঘরের checkout-এর লিখিত লক্ষ্য: “চলমান ২৮ দিনে ৯৯% checkout request (POST /api/orders) ৮০০ ms-এর মধ্যে সফল। ঈদের সেলে প্রত্যাশিত সর্বোচ্চ ভার সাধারণ peak-এর ৪ থেকে ৬ গুণ। সাধারণ peak-এ একসাথে ৪০ জন checkout করেন।” এই spec থেকে সেলের আগের চারটি performance test লিখুন: প্রতিটির ধরন, ভার, সময় আর pass/fail-এর শর্ত।

    একটি সম্ভাব্য সেট (ভার spec থেকে: ৪০ × ৪ = ১৬০, ৪০ × ৬ = ২৪০ জন):

    T1 load   : 160 users, 30 min, realistic journey
                pass: p99 ≤ 800 ms AND error ≤ 1% on POST /api/orders
    T2 load   : 240 users (upper end of the range), 30 min, same pass rule
    T3 stress : 240 → 480 users in steps; record breaking point,
                failure type (slow vs 503) and recovery time after drop
    T4 soak   : 160 users, several hours; pass: no upward trend in
                memory, connections or p99 after warm-up

    কেন এভাবে: SLO বলে “৯৯% ৮০০ ms-এর মধ্যে সফল”, তাই gate-এ p95 নয়, p99 আর সাথে error-এর হার (৯৯% ভালো মানে ধীর আর ব্যর্থ মিলে ১%-এর বেশি নয়)। ভার একটি সংখ্যা নয়, spec-এর পরিসরের দুই প্রান্ত; ওপরের প্রান্তে (২৪০) পাস করা জরুরি। Stress test-এর কোনো pass নেই, আছে তিনটি মাপ: কোথায় ভাঙে, কীভাবে ভাঙে, কত দ্রুত ফেরে। Checkout database-এ লেখে, তাই test data-র reset আর নকল payment (বাজারঘরের FAKE gateway) লাগবে, আর journey-তে কার্টে যোগ থেকে order পর্যন্ত পুরো পথ।

  2. Gate-এর ফল অনুমান করুন: একটি gate-এর নিয়ম: SLO p95 ≤ ৩০০ ms, error ≤ ১%; regression তখনই, যখন বৃদ্ধি baseline-এর ২০%-এর বেশি এবং ১৫ ms-এর বেশি। Baseline p95 = ২১ ms. তিনটি build-এর মাপ: (ক) p95 ৩০ ms, error ০%; (খ) p95 ৪০ ms, error ০%; (গ) p95 ২৮০ ms, error ১.৫%. প্রতিটির gate-এর ফল আর exit code কী, আর কোন লাইনে FAIL ছাপা হবে?

    (ক) বৃদ্ধি ৯ ms: ২১-এর ২০% = ৪.২ ms ছাড়িয়েছে, কিন্তু ১৫ ms ছাড়ায়নি; দুটি শর্ত একসাথে লাগে, তাই GATE PASSED, exit 0. (খ) বৃদ্ধি ১৯ ms: ৪.২ আর ১৫ দুটোই ছাড়িয়েছে, তাই FAIL REGRESSION: p95 21 -> 40 ms (+19 ms), GATE FAILED, exit 1; SLO-র অনেক নিচে থেকেও। (গ) p95 ২৮০, SLO-র ভেতরে, কিন্তু error ১.৫% > ১%, তাই FAIL SLO: error rate 1.50% > 1%; আর বৃদ্ধি ২৫৯ ms, তাই FAIL REGRESSION: p95 21 -> 280 ms (+259 ms); দুটি FAIL লাইন, exit 1. শিক্ষা: (ক) noise-এর পরিসরের ভেতরে, (খ) চুপচাপ জমা অবনতি, (গ) latency ঠিক দেখালেও error SLO ভাঙে। এই হিসাবগুলো এই পর্বের perf_gate.py-এর নিয়মে একটি ছোট script দিয়ে যাচাই করা।

  3. এই performance রিপোর্টে ভুল খুঁজুন: একজন সহকর্মীর রিপোর্ট; অন্তত পাঁচটি সমস্যা খুঁজুন।
    Capacity test, বাজারঘর search
    Target: https://www.(a popular shopping site).com/search  (ওদের মতো ভার দেখতে)
    Run: 10 s, 500 users, no think time, my laptop (app + load tool together)
    Result: average 180 ms → SLO "average ≤ 200 ms" PASSED
    Errors: 312 "connection refused", ignored (probably my laptop)
    Old build last month: 150 ms. New: 180 ms. Conclusion: regression of 20%.
    Capacity: our server handles 500 users, enough for Eid sale.

    (১) অন্যের website-এ load test: অনুমতি ছাড়া এটি আক্রমণের সমান, আর বাজারঘরের ক্ষমতা সম্পর্কে কিছুই বলে না; শুধু নিজের app-এর নিজের পরিবেশে। (২) ১০ সেকেন্ড: warm-up-ই শেষ হয় না; ধাপে ভার বাড়িয়ে কয়েক মিনিট লাগে। (৩) গড়ের SLO: লক্ষ্য percentile আর জানালার ভাষায় হওয়া উচিত, যেমন p95. (৪) Error উপেক্ষা: ৩১২টি ব্যর্থতা “সম্ভবত ল্যাপটপ” বলে বাদ দেওয়া যায় না; load generator-এর error (যেমন port ফুরানো) আর app-এর error আলাদা করে প্রমাণসহ লিখতে হয়। (৫) ভিন্ন মাসের তুলনা: এক মাস আগের একটি run-এর সাথে আজকের একটি run, ভিন্ন পরিবেশে; regression দাবির আগে পরপর, একাধিক run আর noise-এর পরিসর লাগে। (৬) Think time ছাড়া ৫০০ জন একই ল্যাপটপে: closed model, generator আর app CPU ভাগ করে; “৫০০ users সামলায়” কথাটির অর্থ নেই। (৭) Capacity-র সিদ্ধান্ত: সেলের ভার কত, peak factor কত, headroom আর N+1, কিছুই নেই; “যথেষ্ট” কথাটি কোনো হিসাব থেকে আসেনি।

  4. Error budget-এর হিসাব: একটি SLO: ৩০ দিনে ৯৯.৯% request ভালো। মাসে প্রত্যাশিত মোট request ২০,০০,০০০, সমানভাবে ছড়ানো। প্রথম ১০ দিনে খারাপ request ১,৫০০টি। (ক) পুরো মাসের বাজেট কত? (খ) কত শতাংশ খরচ হয়েছে? (গ) এই ১০ দিনের burn rate কত? (ঘ) এই হারে চললে বাজেট কোন দিনে শেষ হবে, আর দলের কী করা উচিত?

    (ক) ২০,০০,০০০ × ০.০০১ = ২,০০০টি খারাপ request. (খ) ১,৫০০ ÷ ২,০০০ = ৭৫%, মাসের এক-তৃতীয়াংশ সময়ে। (গ) ১০ দিনে request ২০,০০,০০০ ÷ ৩ ≈ ৬,৬৬,৬৬৭; খারাপের হার ১,৫০০ ÷ ৬,৬৬,৬৬৭ = ০.২২৫%; burn rate = ০.২২৫% ÷ ০.১% = ২.২৫. (ঘ) প্রতিদিন ১৫০টি খারাপ; বাকি ৫০০টি আরও প্রায় ৩.৩ দিনে শেষ, অর্থাৎ ১৪তম দিনে (৩০ ÷ ২.২৫ ≈ ১৩.৩ দিন)। সাধারণ বাজেট নীতিতে: ঝুঁকিপূর্ণ release থামানো, খারাপ request কোথা থেকে আসছে তা খোঁজা (কোন endpoint, কোন সময়), আর সংশোধনের পরে performance test-এ একই পথে gate যোগ করা। সংখ্যাগুলো একটি ছোট script দিয়ে যাচাই করা।

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

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

ক্রমএকটি বড় সেলের আগে SLO-ভিত্তিক performance কাজের যুক্তিসঙ্গত ক্রম সাজান (▲▼ চেপে সরান)

  1. SLI আর SLO লেখা — কোন request ভালো, কোন percentile, কোন জানালা
  2. আগের build-এ baseline run — একই ভার, একই যন্ত্র
  3. প্রত্যাশিত সেল-ভারে load test আর gate — SLO ও baseline-এর সাথে তুলনা
  4. Stress test — breaking point, ভাঙনের ধরন আর ফিরে আসার সময়
  5. Soak test — দীর্ঘ সময়ে leak বা ধীরে বাড়া latency খোঁজা
  6. Capacity plan — headroom আর N+1 ধরে worker-এর সংখ্যা ঠিক করা

“চলমান ২৮ দিনে ৯৯.৫% search request ৩০০ ms-এর মধ্যে সফল হবে” — এই বাক্যটি কী?

  • SLI
  • SLA
  • SLO
  • Error budget

একটি SLO-র লক্ষ্য ৯৯.৫%, জানালায় মোট ৪,০০,০০০ request. Error budget অনুযায়ী এই জানালায় সর্বোচ্চ কতগুলো খারাপ request মেনে নেওয়া যায়?

  • ২০০
  • ২,০০০
  • ২০,০০০
  • ৩,৯৮,০০০

M/M/1 মডেলে গড় response time = S/(১ − ρ). একটি server-এর ব্যস্ততা ρ ০.৫০ থেকে বেড়ে ০.৯০ হলো, সেবার গড় সময় S একই। গড় response time কত গুণ হবে?

  • ১.৮ গুণ
  • ২ গুণ
  • ব্যস্ততার সমান হারে, ১.৮ গুণ, কারণ সম্পর্কটি সরলরেখা
  • ৫ গুণ

একটি performance gate-এর নিয়ম: SLO p95 ≤ ৩০০ ms; regression তখনই, যখন বৃদ্ধি baseline-এর ২০%-এর বেশি এবং ১৫ ms-এর বেশি। Baseline p95 ২১ ms, নতুন build-এর p95 ৩০ ms, কোনো error নেই। Gate-এর ফল কী?

  • PASSED, কারণ বৃদ্ধি ১৫ ms-এর কম
  • FAILED, কারণ বৃদ্ধি ২০%-এর বেশি
  • FAILED, কারণ SLO ভেঙেছে
  • সিদ্ধান্ত নেওয়া যায় না, আবার চালাতে হবে

একটি Python app-এর প্রতিটি worker-এ ৪০টি thread-এর pool, আর প্রতিটি ধীর search ১.৫ সেকেন্ড একটি thread আটকে রাখে। ৬০ জন ব্যবহারকারী think time ছাড়া, keep-alive connection-এ search করছেন। Worker ১ থেকে ২ করার পরেও p95 প্রায় ৩ সেকেন্ড রইল; প্রতি request-এ নতুন connection দিতেই p95 ১.৫ সেকেন্ড। সবচেয়ে সম্ভাব্য ব্যাখ্যা কোনটি?

  • দ্বিতীয় worker আসলে চালু হয়নি
  • দুই worker মিলেও thread ৪০টিই থাকে
  • Keep-alive connection দুই worker-এ অসমভাবে ভাগ হয়েছিল
  • নতুন connection নিজে থেকেই দ্রুত

একটি ৪ মিনিটের ছোট soak run-এ app-এর memory প্রথম ৩০ সেকেন্ডে ৫০.৮ থেকে ৫৬.৪ MB, তারপর শেষ পর্যন্ত ৫৬.৩–৫৬.৫ MB; p95 প্রতি মিনিটে ১৭–২৩ ms, কোনো error নেই। সবচেয়ে সঠিক সিদ্ধান্ত কোনটি?

  • App-এ কোনো memory leak নেই, প্রমাণিত
  • এই ৪ মিনিটে গরম হওয়ার পরে leak-এর লক্ষণ নেই; দীর্ঘ soak ছাড়া ধীর leak বাদ দেওয়া যায় না
  • প্রথম ৩০ সেকেন্ডে ৫.৬ MB বেড়েছে, তাই leak আছে
  • Error নেই, তাই soak-এর ফল দেখার দরকার নেই

শব্দকোষ

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

মনে রাখুন

  1. SLI মাপ, SLO লক্ষ্য + জানালা, SLA চুক্তি: latency-র লক্ষ্য percentile-এ, গড়ে নয়; error budget হলো লক্ষ্যের উল্টো দিক, আর সেল-সপ্তাহের ভিড়ে তা দ্রুত ফুরায়।
  2. Gate দুই প্রশ্নে: SLO ভাঙল কি, আর baseline থেকে noise-এর সীমা (২০% এবং ১৫ ms) ছাড়িয়ে খারাপ হলো কি; সত্যিকারের run-এ +৬০ ms SLO-র ভেতরেও ধরা পড়ল।
  3. Utilisation-এর curve বাঁকা: M/M/1-এ ৫০% থেকে ৯০%-এ p95 পাঁচ গুণ; stress run-এ throughput প্রায় ৭৫০ req/s-এ আটকে p95 সরলরেখায় বাড়ল।
  4. দুই worker ≠ দ্বিগুণ: পরিষ্কার build-এ ১.৮৬ গুণ; ধীর search-এ keep-alive-এর অসম ভাগ সুবিধা নষ্ট করল, নতুন connection-এ p95 ৩ s থেকে ১.৫ s.
  5. ভাঙন, ফিরে আসা, soak আর plan: load generator-এর error আলাদা করুন; ছোট soak থেকে শুধু “লক্ষণ নেই” বলুন; capacity plan একটি পরিসর, headroom আর N+1-সহ।

পরের পর্বে: Frontend performance — ব্যবহারকারী আসলে কী অনুভব করেন, Core Web Vitals (LCP, INP, CLS), Lighthouse দিয়ে নিজের app-এর পাতা মাপা, আর একটি ইচ্ছাকৃত ধীরতা budget দিয়ে ধরা।

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

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