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

Chaos আর resilience testing — ইচ্ছাকৃত গোলমালে system যাচাই

Chaos and Resilience Testing — Steady State, Fault Injection, Blast Radius and Resilience Patterns

Taught in Bangla, this lesson frames chaos engineering as a controlled test on your own localhost, never as breaking someone else's system. Real Toxiproxy and Chaos Toolkit runs show a latency hypothesis holding at 100 ms and deviating at 250 ms; a slow fake wallet drops cash checkout success to 13.6% until a global lock is moved, a lost wallet reply leaves paid-but-unpaid orders, and a process is killed under load. Unit tests then check retry, backoff and a circuit breaker.

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

  • একটি chaos experiment-কে test-এর মতো সাজানো: steady state, hypothesis, blast radius, abort condition, rollback আর control
  • Fault-এর ধরন (latency, error, process kill, dependency বন্ধ, resource শেষ, ঘড়ির গরমিল) থেকে কোন resilience pattern যাচাই হয়, তা মেলানো
  • নিজের localhost-এ Toxiproxy আর Chaos Toolkit দিয়ে একটি সত্যিকারের experiment চালানো আর তার রায় পড়া
  • Load চলার সময় fault ঢুকিয়ে সাফল্যের হার, p95, throughput আর ফিরে আসার সময় মাপা, আর টাকার হিসাব মিলিয়ে correctness যাচাই
  • Retry, backoff, jitter আর circuit breaker-এর কোডকে simulation আর unittest দিয়ে যাচাই করা

১ · ইচ্ছা করে গোলমাল — কেন, আর কোথা থেকে

অনেক হাসপাতালে মাসে একবার ইচ্ছা করে মূল বিদ্যুৎ বন্ধ করে দেখা হয়, জেনারেটর নিজে থেকে চালু হয় কি না। লোডশেডিং-এর রাতে প্রথমবার জানতে পারা যে জেনারেটরের তেল শেষ, তা কেউ চান না। তবে মহড়াটি হয় দিনের বেলা, সবাই জানেন, অপারেশন থিয়েটার আলাদা লাইনে, আর কিছু গড়বড় হলে সঙ্গে সঙ্গে মূল লাইন ফেরানোর মানুষ পাশে দাঁড়ানো। Software-এ এই অভ্যাসের নাম chaos engineering: নিয়ন্ত্রিতভাবে ব্যর্থতা ঘটিয়ে দেখা, system প্রত্যাশামতো টিকে থাকে কি না।

Tester-এর ভাষায় এটি resilience testing: ব্যর্থতা, ধীরতা বা চাপের মধ্যে system কতটা কাজ চালায়, আর কত দ্রুত স্বাভাবিক হয়। পর্ব ৫৭-এ (Compatibility আর reliability) একবার payment-এর মাঝে server বন্ধ করে দেখেছেন data ঠিক থাকে কি না: একটি নির্দিষ্ট ঘটনা, একটি যাচাই। এই পর্ব এক ধাপ এগোয়: load চলার সময় নানা ধরনের fault ঢোকানো, প্রতিবার একটি মাপা দাবি নিয়ে, আর দাবির বিপরীতে রায়।

ধারণাটি জনপ্রিয় হয় Netflix-এর হাত ধরে। ২০১০–২০১১ সালের দিকে তারা Chaos Monkey নামের একটি টুল বানায়, যা কাজের সময়ে এলোমেলোভাবে production-এর server বন্ধ করত; ২০১২ সালে এর code উন্মুক্ত হয় বলে জানা যায়। পরে Netflix-এর প্রকৌশলীরা নীতিগুলো “Principles of Chaos Engineering” নামে লিখে প্রকাশ করেন (২০১৫ সালের দিকে)। এর আগেও বড় প্রতিষ্ঠানে নির্ধারিত দিনে বিপর্যয়ের মহড়ার চল ছিল, যার নাম game day. Chaos-এর ইতিহাস, Kubernetes-এ Pod মুছে পরীক্ষা আর capacity-র দিকটি পাবেন ক্লাউড ও DevOps কোর্সের পর্ব ৬৮-এ; এখানে দৃষ্টি tester-এর: experiment-কে কীভাবে একটি নির্ভরযোগ্য test বানাবেন।

মূল ধারণা

সাধারণ test জিজ্ঞেস করে, “এই input-এ এই output আসে কি?” Chaos experiment জিজ্ঞেস করে, “এই ব্যর্থতা ঘটলেও ব্যবহারকারীর চোখে স্বাভাবিক আচরণটি টিকে থাকে কি?” প্রশ্নটি আগে থেকে লেখা হয়, উত্তর মাপা হয় সংখ্যায়, আর রায় দুটি: টিকল (আস্থা বাড়ল) বা ভাঙল (একটি দুর্বলতা পাওয়া গেল, যা fix করে আবার একই experiment চালাতে হবে)।

২ · একটি experiment-এর কাঠামো — দাবি, পরিধি আর থামার নিয়ম

প্রতিটি experiment-এর আগে ছয়টি জিনিস কাগজে লিখুন। বাজারঘরের উদাহরণে:

অংশমানেবাজারঘরে
Steady stateবাইরে থেকে মাপা স্বাভাবিক আচরণ২০ জন user-এ checkout-এর সাফল্য, journey-র p95, throughput
HypothesisFault-এর মধ্যেও যে সংখ্যা ঠিক থাকবে বলে দাবিসাফল্য ≥ ৯৯%, p95 ≤ ১০০০ ms
Faultবাস্তবের মতো একটি ঘটনাউত্তরে ২৫০ ms দেরি; wallet ধীর; process বন্ধ
Blast radiusকতটুকু জায়গা ঝুঁকিতেশুধু নিজের localhost, নিজের database, ২০ জন নকল user
Abort conditionযে সীমা পেরোলে সঙ্গে সঙ্গে থামাশেষ ১০ সেকেন্ডে সাফল্য ৫০%-এর নিচে
RollbackFault সরিয়ে আগের অবস্থায় ফেরাToxic মোছা; wallet mode আবার success

Steady state বাছাইয়ে সবচেয়ে প্রচলিত ভুল হলো /api/health-কে মাপকাঠি করা। পর্ব ৫৭-এ দেখেছেন, বাজারঘরের health শুধু “ok” বলে, database পড়তে পারে কি না দেখে না। মাপুন ব্যবহারকারী যা অনুভব করেন: অর্ডার সফল হলো কি, কত সময় লাগল। এগুলো আসলে আপনার SLI, আর hypothesis-এর সীমা প্রায়ই SLO থেকে আসে, যা পর্ব ৫০-এ (SLO-ভিত্তিক test) শিখেছেন। সেখানে error budget-এর হিসাবও আছে: experiment নিজেও কিছু বাজেট খরচ করে, তাই বাজেট প্রায় শেষ থাকলে experiment নয়।

আরেকটি অংশ প্রায়ই বাদ পড়ে: control. যন্ত্র, network বা data-র স্বাভাবিক ওঠানামাতেও সংখ্যা বদলায়। একই সময়ে fault ছাড়া চলা একটি তুলনার run বা অংশ থাকলে বলা যায় পার্থক্যটি fault-এর জন্য কি না। §৭-এ দেখবেন এটি কেন জরুরি।

পরিধি বাড়ানো হয় ধাপে ধাপে, প্রতিটি ধাপে শিখে। নিচের পাঁচটি বলয় দেখুন; এই পর্বের সব run প্রথম দুই বলয়ে।

  1. কোডের ভেতরেunitনকল ঘড়ি, simulator
  2. নিজের ল্যাব127.0.0.1২০ জন নকল user
  3. Stagingstagingproduction-এর মতো
  4. ছোট অংশ1%একটি cell বা canary
  5. নিয়মিতscheduleস্বয়ংক্রিয়, game day
  1. বলয় ১ — কোডের ভেতরে। Retry বা circuit breaker-এর logic নকল ঘড়ি আর নকল dependency দিয়ে unittest-এ যাচাই (§৮). ঝুঁকি শূন্য, খরচ কয়েক মিলিসেকেন্ড। এখানে যে bug ধরা পড়ে, তার জন্য বড় পরিবেশ লাগে না।
  2. বলয় ২ — নিজের ল্যাব। App-এর নিজের কপি, নিজের database, নিজের port, ছোট load (§৪–৭). Process বন্ধ হয় শুধু নিজের শুরু করা process-এর PID ধরে। পরের বলয়ে যাওয়ার শর্ত: এখানকার সব জানা দুর্বলতা সারানো।
  3. বলয় ৩ — Staging. Production-এর মতো গঠন, আসল ধাঁচের data-র নকল কপি, synthetic load (staging environment). এখানে ধরা পড়ে configuration আর একাধিক service-এর জোড়ার সমস্যা।
  4. বলয় ৪ — Production-এর ছোট অংশ। একটি cell বা অল্প শতাংশ traffic, স্বয়ংক্রিয় abort condition, ঘোষিত সময়, আর observability চালু। পূর্বশর্ত: ভালো monitoring আর দ্রুত rollback; না থাকলে experiment-এর ফলই দেখা যাবে না। Production-এ নিরাপদে test করার কৌশল পর্ব ৬৬-এর (Production-এ testing — canary, feature flag আর synthetic monitoring) বিষয়।
  5. বলয় ৫ — নিয়মিত। যে experiment বারবার টিকেছে, তা সূচি ধরে স্বয়ংক্রিয় চলে, যাতে নতুন release পুরোনো সুরক্ষা ভেঙে দিলে ধরা পড়ে। পাশাপাশি game day-তে মানুষের সাড়া, alert আর runbook-ও যাচাই হয়।

নিরাপত্তার নিয়ম: অন্যের system, শেয়ার করা server বা production-এ অনুমতি, abort condition আর rollback ছাড়া কখনো fault ঢোকাবেন না। নাম ধরে process মারা (pkill python, taskkill /IM) চলবে না; শুধু নিজের শুরু করা process, তার PID দিয়ে। Load ছোট রাখুন, সময় সীমিত রাখুন। নিরাপত্তা আর অনুমতির সাধারণ নীতি পর্ব ৫২-এ (Security testing) আছে; একই নীতি এখানেও খাটে।

৩ · Fault-এর ধরন আর যে সুরক্ষা আপনি যাচাই করছেন

প্রতিটি fault একটি নির্দিষ্ট সুরক্ষার প্রশ্ন তোলে। Fault injection-এর মূল ধারণা পর্ব ৩৪-এ (Service virtualization) virtual wallet-এ দেখেছেন; সেখানে একটি নকল dependency থেকে ত্রুটি আসত, আর test দেখত app-এর একটি অনুরোধ কী করে। এখানে প্রশ্ন পুরো system-এর, load চলা অবস্থায়:

Faultকীভাবে ঢোকানোযে সুরক্ষা যাচাই হয়কী মাপবেন
দেরি (latency)Proxy-তে toxicTimeout, deadlinep95, throughput
Error উত্তরনকল dependency-র modeRetry, fallbackসাফল্যের হার, ভুল charge
Process বন্ধনিজের PID-এ killRestart, idempotencyফিরে আসার সময়, data
Dependency ধীর বা বন্ধDelay, বিচ্ছিন্নতাBulkhead, circuit breakerঅন্য পথের ক্ষতি
Resource শেষDisk ভরা, connection সীমাLoad shedding, স্পষ্ট errorError-এর ধরন, recovery
ঘড়ির গরমিলনকল ঘড়ি, সময় সরানোমেয়াদ, token, সূচিভুল মেয়াদোত্তীর্ণ

Resilience pattern-গুলোর নকশা, অর্থাৎ timeout-এর বাজেট, retry কোন error-এ, exponential backoff-এর সাথে jitter, circuit breaker-এর তিন অবস্থা আর bulkhead, বিস্তারে আছে সিস্টেম ডিজাইন কোর্সের পর্ব ৪৮-এ। Tester-এর প্রশ্ন সেগুলোর চেয়ে সরল আর কঠোর: নকশায় যা লেখা আছে, কোডে কি সত্যিই আছে, আর fault ঢোকালে কি সত্যিই কাজ করে? সবচেয়ে বিপজ্জনক ফল হলো cascading failure: একটি অংশের সমস্যা শিকলের মতো অন্য অংশে ছড়ানো। §৬-এ ঠিক এটিই দেখবেন।

ঘড়ির fault আলাদা করে মনে রাখুন। ঘড়ি সামনে-পিছে সরলে token-এর মেয়াদ, order বাতিলের সময়সীমা বা রাতের হিসাব-মেলানোর কাজ ভুল সময়ে চলতে পারে। এর সবচেয়ে সস্তা test বলয় ১-এ: নকল ঘড়ি (fake clock), যা পর্ব ২৪-এ (Test double গভীরে) শিখেছেন, আর §৮-এর circuit breaker-এর test-ও তাই করে।

৪ · ল্যাব — বাজারঘর, Toxiproxy আর Chaos Toolkit

এই পর্বের সব সত্যিকারের run একটি আলাদা scratch ফোল্ডারে: বাজারঘরের app (MIT) নিজের কপি থেকে 127.0.0.1:8846-এ, test mode-এ, নিজের database ফাইলে, Python 3.12.13 আর Uvicorn 0.54.0-এ। নিজের কপির database-এ ২৪ জন বানানো ক্রেতা (load01 থেকে load24) যোগ করা হয়েছে, আর ডালের স্টক বাড়ানো হয়েছে, যাতে load চলার সময় স্টক ফুরিয়ে ভুল ব্যর্থতা না আসে। Load-এর জন্য নিজের লেখা একটি ছোট script, httpx 0.28.1 (BSD-3-Clause) আর asyncio দিয়ে।

Network-এর fault ঢোকানো হয়েছে Toxiproxy 2.13.0 দিয়ে (MIT লাইসেন্স, নির্মাতা Shopify; অফিশিয়াল release-এর Windows binary, checksum মিলিয়ে)। এটি একটি TCP proxy: load script app-কে সরাসরি না ডেকে proxy-কে ডাকে (127.0.0.1:18846), আর proxy-র HTTP API-তে (127.0.0.1:18474) চলার মধ্যেই “toxic” যোগ বা মোছা যায়, যেমন দেরি। Experiment চালিয়েছে Chaos Toolkit 1.21.4 (chaostoolkit-lib 1.45.1, Apache-2.0), নিজের uv পরিবেশে। Chaos Toolkit প্রতিবার চালু হওয়ার সময় তার release server-কে নিজের version আর command-এর নাম জানিয়ে নতুন version খোঁজে; তাই প্রতিটি run-এ --no-version-check, --no-log-file আর ল্যাবের ভেতরের নিজের settings ফাইল দেওয়া হয়েছে। সব অনুরোধ শুধু 127.0.0.1-এ।

ল্যাবের গঠন আর fault-এর জায়গা

Lab layout and fault injection points

ল্যাব: Chaos Toolkit, load script, Toxiproxy, বাজারঘর app, নকল wallet আর SQLite; চারটি fault-এর জায়গা Chaos Toolkit · experiment.json আগে probe → fault → পরে probe → rollback load.py · ২০ জন নকল user search → cart → order → pay Toxiproxy · :18846 ⚡ E1: প্রতি উত্তরে দেরি (latency toxic) বাজারঘর app · :8846 ⚡ E4: load চলার সময় process kill নকল wallet (app-এর ভেতরে) ⚡ E2: ১৫০০ ms ধীর · E3: timeout SQLite · chaos.db প্রতি run-এর পরে order ↔ ledger মেলানো
ছবি ৬৩.১ — চারটি experiment (E1–E4), চারটি আলাদা জায়গায় fault. প্রতিটির পরে শুধু সংখ্যা নয়, database-এর টাকার হিসাবও মেলানো হয়েছে।

Load script-এর মূল অংশ। প্রতিটি নকল user একবার login করে, তারপর বারবার একটি পূর্ণ journey চালায়; জোড় নম্বরের user ক্যাশে, বিজোড় নম্বরের user mobile-wallet-এ পে করেন। প্রতি ৫ সেকেন্ডে একটি পাহারাদার শেষ ১০ সেকেন্ডের সাফল্য দেখে, আর তা ৫০%-এর নিচে নামলে পুরো run থামায়: এটিই abort condition.

r = await c.get("/api/products", params={"q": "dal"})
await c.post("/api/cart/items", json={"product_id": 2, "qty": 1}, headers=h)
r = await c.post("/api/orders", headers=h, json={..., "payment_method": kind})
oid = r.json()["id"]
await c.post(f"/api/orders/{oid}/pay",
             headers={**h, "Idempotency-Key": uuid.uuid4().hex})

async def watchdog():                    # abort condition
    for _ in range(int(args.seconds / 5)):
        await asyncio.sleep(5)
        recent = [d for d in done if d["t"] > now() - 10]
        if len(recent) >= 10 and success(recent) < args.abort:
            stop.set(); return "ABORT"

প্রথমে কোনো fault ছাড়া ভিত্তি (baseline), ৩০ সেকেন্ড, ২০ জন user. সত্যিকারের আউটপুট:

[baseline] users=20 journeys=1357 success=100.0% p95=354 ms
  cash          n= 678 ok=100.0% p50=256 p95=355 ms
  mobile-wallet n= 679 ok=100.0% p50=254 p95=353 ms
  hypothesis (ok>=99%, p95<=1500 ms): HOLDS

প্রতিটি journey-তে চারটি অনুরোধ, আর p95 ৩৫৪ ms. এই সংখ্যা দেখেই পরের experiment-গুলোর সীমা ঠিক হয়েছে: সাফল্য ≥ ৯৯%, p95 ≤ ১০০০ ms, ভিত্তির প্রায় তিন গুণ। Load-এর মাপ ছোট রাখা হয়েছে ইচ্ছা করে (২০ জন, প্রতি experiment দুই মিনিটের কম), কারণ লক্ষ্য capacity মাপা নয়, ব্যর্থতার আচরণ দেখা। Load-এর হাতিয়ার আর closed workload-এর ধারণা পর্ব ৪৭-এ (Locust দিয়ে load test).

৫ · Experiment ১ — দেরি, আর Chaos Toolkit-এর রায়

প্রশ্ন: ক্রেতা আর server-এর মাঝে প্রতি উত্তরে বাড়তি দেরি এলে checkout কি SLO-র মধ্যে থাকে? Chaos Toolkit-এর experiment ফাইলে তিনটি অংশ: steady-state hypothesis (একটি probe, যা ২০ সেকেন্ডের load চালিয়ে exit code দেয়, ০ মানে দাবি টিকেছে), method (Toxiproxy-র API-তে একটি latency toxic যোগ), আর rollbacks (toxic মোছা)। মূল অংশ:

"steady-state-hypothesis": {
  "title": "20 users: checkout ok >= 99% and p95 <= 1000 ms",
  "probes": [{"type": "probe", "name": "checkout-slo-under-load",
    "tolerance": 0,
    "provider": {"type": "process", "path": "python", "timeout": 60,
      "arguments": ["load.py", "--users", "20", "--seconds", "20",
                    "--min-ok", "0.99", "--max-p95", "1000"]}}]},
"method": [{"type": "action", "name": "add-latency-250ms",
  "provider": {"type": "http", "method": "POST",
    "url": "http://127.0.0.1:18474/proxies/bazarghar/toxics",
    "arguments": {"name": "lat", "type": "latency", "stream": "downstream",
                  "attributes": {"latency": 250, "jitter": 20}}}}],
"rollbacks": [{"type": "action", "name": "remove-latency",
  "provider": {"type": "http", "method": "DELETE",
    "url": "http://127.0.0.1:18474/proxies/bazarghar/toxics/lat"}}]

একই ফাইল দুইবার চালানো হলো, একবার ১০০ ms, একবার ২৫০ ms দেরিতে (jitter ±২০ ms). ২৫০ ms-এর সত্যিকারের run (Chaos Toolkit-এর আউটপুট; তারিখ আর পাঁচটি সাধারণ তথ্যের লাইন বাদ):

$ chaos --no-version-check --no-log-file --settings ./ctk-settings.yaml \
    run --rollback-strategy always --journal-path journal_250.json exp_latency_250.json
[20:16:08 INFO] Steady state hypothesis: 20 users: checkout ok >= 99% and p95 <= 1000 ms
[20:16:08 INFO] Probe: checkout-slo-under-load
[20:16:28 INFO] Steady state hypothesis is met!
[20:16:28 INFO] Playing your experiment's method now...
[20:16:28 INFO] Action: add-latency-250ms
[20:16:28 INFO] Probe: checkout-slo-under-load
[20:16:50 CRITICAL] Steady state probe 'checkout-slo-under-load' is not in the given tolerance so failing this experiment
[20:16:50 WARNING] Rollbacks were explicitly requested to be played
[20:16:50 INFO] Rollback: remove-latency
[20:16:50 INFO] Experiment ended with status: deviated
[20:16:50 INFO] The steady-state has deviated, a weakness may have been discovered
exit=1

দুই run-এর চারটি probe-এর প্রথম লাইন, journal ফাইল থেকে এক লাইনে সংক্ষেপ করা:

100 ms  before: journeys=691 success=100.0% p95=495 ms  HOLDS
100 ms  after : journeys=511 success=100.0% p95=850 ms  HOLDS
250 ms  before: journeys=844 success=100.0% p95=383 ms  HOLDS
250 ms  after : journeys=312 success=100.0% p95=1142 ms DEVIATED
  1. ফাইলjsonদাবি আগে লেখা
  2. আগেprobe৩৮৩ ms
  3. Fault+250 mstoxic যোগ
  4. পরেprobe১১৪২ ms
  5. RollbackDELETEtoxic মোছা
  6. রায়deviatedexit 1
দাবিrun-এর আগেই লেখা
ok >= 99%  এবং  p95 <= 1000 ms
২০ জন user, প্রতি probe ২০ s
# probe-এর exit 0 = দাবি টিকেছে
আগের probefault নেই
journeys=844  success=100.0%
p95=383 ms  HOLDS
# ভিত্তি ঠিক না থাকলে fault নয়
MethodToxiproxy API
POST /proxies/bazarghar/toxics
latency 250, jitter 20, downstream
# app জানেই না, পথটি ধীর
পরের probefault চালু
journeys=312  success=100.0%
p95=1142 ms  DEVIATED
# 4 অনুরোধ × 250 ms = 1000
Rollback--rollback-strategy always
DELETE …/toxics/lat  → 204
toxics এখন: []
রায়journal ফাইলে
status: deviated, exit=1
# ১০০ ms-এ: completed, exit=0
  1. দাবি আগে। সীমাগুলো run-এর আগেই ফাইলে লেখা, ফল দেখে বদলানো যায় না। Probe একটি process: load.py ২০ সেকেন্ড চলে, আর দাবি টিকলে exit code ০ দেয়; "tolerance": 0 মানে ঠিক এটিই প্রত্যাশা।
  2. আগের মাপ। Fault ছাড়া p95 ৩৮৩ ms, সাফল্য ১০০%. Chaos Toolkit এখানে দাবি না টিকলে method-ই চালায় না: অস্বাভাবিক system-এ fault ঢুকিয়ে কিছু শেখা যায় না।
  3. Fault. Toxiproxy-র API-তে একটি toxic: proxy থেকে ক্রেতার দিকে যাওয়া প্রতিটি উত্তর ২৫০ ms (±২০) দেরিতে। App নিজে দ্রুতই থাকে, শুধু পথটি ধীর।
  4. পরের মাপ, দাবি ভাঙল। সাফল্য তবু ১০০%, কিন্তু p95 ১১৪২ ms, সীমা ১০০০. হিসাবটি সরল: journey-তে চারটি অনুরোধ, প্রতিটিতে ২৫০ ms, শুধু দেরিই ১০০০ ms. অর্থাৎ এত ধীর পথে চার ধাপের checkout SLO রাখতে পারে না; উত্তর হতে পারে ধাপ কমানো, বা সেই network-এর জন্য আলাদা SLO.
  5. Rollback. Toxic মোছা হলো, API বলল ২০৪, তালিকা খালি। সাবধান: Chaos Toolkit-এর নিজের সাহায্য-বার্তা বলে, ডিফল্টে run বাধা পেলে বা hypothesis ব্যর্থ হলে rollback চলে না। chaostoolkit-lib 1.45.1-এর কোডে সূক্ষ্মতাটি এমন: probe ঠিকমতো চলে শুধু সীমা ভাঙলে (এই run-এর মতো) journal-এর status থাকে completed, আর তখন ডিফল্টেও rollback চলে; কিন্তু probe নিজেই error দিলে (status failed) বা run বাধা পেলে চলে না। এই সূক্ষ্মতার ওপর ভরসা না করে --rollback-strategy always দেওয়া হয়েছিল।
  6. রায়। “deviated”, exit code ১, যা CI-তে একটি লাল ধাপ বানাতে পারে। একই ফাইল ১০০ ms-এ “completed”, exit ০. দুই রায় মিলিয়ে বলা যায় দাবিটি ১০০ আর ২৫০ ms-এর মাঝে কোথাও ভাঙে; প্রয়োজন হলে মাঝের মান দিয়ে আবার experiment.

লুকানো সংকেত: ১০০ ms-এর run-এ দাবি টিকেছে, কিন্তু ২০ সেকেন্ডে journey ৬৯১ থেকে নেমে ৫১১, প্রায় ২৬% কম। p50 বেড়েছে মাত্র ৪০১ থেকে ৫২৮ ms, অথচ চার অনুরোধে দেরি ৪০০ ms যোগ হওয়ার কথা। কারণ load-টি closed: প্রতিটি user আগের উত্তর পেয়ে তবেই পরের অনুরোধ পাঠান, তাই পথ ধীর হলে server-এ ভিড় কমে, আর server-এর অপেক্ষার সময়ও কমে। বাস্তবে ক্রেতারা এভাবে অপেক্ষা করে আসেন না; তাই hypothesis-এ শুধু p95 নয়, throughput-ও রাখুন, নয়তো এমন পতন সবুজ রায়ের আড়ালে থাকবে।

৬ · Experiment ২ ও ৩ — ধীর wallet আর হারানো উত্তর

E2: wallet ১.৫ সেকেন্ড ধীর — cash checkout কি টেকে?

নকশার দাবি: wallet আলাদা একটি dependency; তার সমস্যায় wallet-এ পে করা ক্রেতারা ধীর হবেন, কিন্তু ক্যাশের ক্রেতারা টের পাবেন না। Hypothesis তাই শুধু cash journey নিয়ে: সাফল্য ≥ ৯৯%, p95 ≤ ১০০০ ms. Fault: app চালু হলো BAZARGHAR_WALLET_DELAY_MS=1500 দিয়ে, অর্থাৎ নকল gateway প্রতিটি charge-এর আগে ১.৫ সেকেন্ড ঘুমায়। Client-এর timeout ৫ সেকেন্ড, run ৬০ সেকেন্ডের জন্য। সত্যিকারের আউটপুট:

[slow-wallet] users=20 journeys=44 judged=cash success=13.6% p95=5070 ms
  cash          n=  22 ok=13.6% p50=2038 p95=5070 ms
  mobile-wallet n=  22 ok=13.6% p50=3561 p95=5071 ms
  errors: {'cart:ReadTimeout': 24, 'pay:ReadTimeout': 14}
  ABORT at 10 s: rolling 10 s success below 50%
  hypothesis (ok>=99%, p95<=1000 ms): DEVIATED

ভিত্তিতে ৩০ সেকেন্ডে ১৩৫৭টি journey হয়েছিল, এখানে ১০ সেকেন্ডে মাত্র ৪৪টি, আর abort condition দশম সেকেন্ডে পুরো run থামিয়ে দিয়েছে। সবচেয়ে বড় খবর error-এর তালিকায়: ২৪টি timeout cart-এ যোগ করার ধাপে, যার সাথে wallet-এর কোনো সম্পর্কই নেই। ক্যাশের ক্রেতারা wallet-এর ক্রেতাদের মতোই আটকে গেছেন। Bulkhead নেই।

কারণ খুঁজতে কোড পড়া হলো। বাজারঘরের সব লেখার কাজ (cart, order, pay, এমনকি login) একটি global write lock-এর ভেতরে হয়, যাতে SQLite-এ লেখা একটি একটি করে যায়। আর pay-এর ভেতরে wallet-এর charge ডাকা হয় সেই lock ধরে রেখেই। Wallet ১.৫ সেকেন্ড ঘুমালে lock-ও ১.৫ সেকেন্ড আটকে থাকে, আর দশজন wallet-ক্রেতা পরপর এলে বাকি সব লেখা ১৫ সেকেন্ডের সারিতে। এটি lock contention-এর চেনা রূপ (পর্ব ৪৯-এ, Performance bottleneck, এর পরিচয় পেয়েছেন), আর এখানে তা একটি ধীর dependency-কে পুরো দোকানের ব্যর্থতায় বদলেছে: cascading failure. স্বাভাবিক দিনে, wallet দ্রুত থাকলে, কোনো test এটি দেখায়নি।

Fix নিজের কপিতে: pay তিন ভাগে, প্রথমে lock-এর ভেতরে অল্প সময়ে যাচাই, তারপর lock ছাড়া wallet-এর ডাক, শেষে আবার lock-এর ভেতরে ফল লেখা। Fix-এর পরে app-এর নিজের ১৫০টি test চালানো হলো, আর একটি লাল হলো: অন্য order-এ ব্যবহৃত Idempotency-Key ধরার যাচাই নতুন পথে বাদ পড়েছিল। সেটি যোগ করার পরে ১৫০টিই সবুজ। শিক্ষা: resilience-এর fix-ও পুরোনো আচরণ ভাঙতে পারে, regression suite ছাড়া fix নয়। তারপর হুবহু একই experiment:

[slow-wallet-fixed] users=20 journeys=1764 judged=cash success=100.0% p95=478 ms
  cash          n=1463 ok=100.0% p50=197 p95=478 ms
  mobile-wallet n= 301 ok=100.0% p50=1792 p95=2147 ms
  hypothesis (ok>=99%, p95<=1000 ms): HOLDS

এবার wallet-ক্রেতারা প্রত্যাশামতো ধীর (p50 ১৭৯২ ms, যার ১৫০০ ms gateway-র ঘুম), কিন্তু ক্যাশের p95 ৪৭৮ ms, সাফল্য ১০০%, আর পুরো ৬০ সেকেন্ড চলেছে। Fault একই, রায় উল্টো: এটিই chaos-এর পূর্ণ চক্র, ভাঙা দাবি থেকে fix, আর একই experiment-এ সবুজ। আসল system-এ একই নীতির আরও রূপ আছে: wallet-এর ডাকের নিজস্ব timeout, তার জন্য আলাদা connection বা thread-এর সীমা, আর বারবার ব্যর্থ হলে circuit breaker.

E3: wallet-এর উত্তর হারায় — টাকার হিসাব কি মেলে?

নকল gateway-র timeout mode বাস্তবের সবচেয়ে কঠিন ঘটনা নকল করে: টাকা কাটা হয়, কিন্তু উত্তর app-এ পৌঁছায় না, app 504 দেয়। Hypothesis তিন ভাগে: (ক) cash-এর ক্ষতি নেই, (খ) wallet-এর ব্যর্থতা দ্রুত, এক সেকেন্ডের মধ্যে, (গ) পরিশোধিত না হওয়া কোনো order-এর জন্য টাকা কাটা থাকবে না। Test-mode-এর PUT /api/test/wallet দিয়ে fault, ২০ সেকেন্ড load, তারপর rollback আর database-এ হিসাব। সত্যিকারের আউটপুট:

[wallet-timeout] users=20 journeys=700 judged=all success=50.1% p95=573 ms
  cash          n= 351 ok=100.0% p50=376 p95=573 ms
  mobile-wallet n= 349 ok=0.0% p50=nan p95=nan ms
  errors: {'pay:504': 349}
failed journeys: 349, slowest failure 647 ms
ledger charges by order status: {'placed': 349}
charged but unpaid: 349 orders, 68055 taka
orders left 'placed': {'mobile-wallet': 349}

(ক) টিকেছে: cash ১০০%. (খ) টিকেছে: সবচেয়ে ধীর ব্যর্থতাও ৬৪৭ ms. (গ) ভেঙেছে, আর সবচেয়ে জোরে: ৩৪৯টি order-এ টাকা কাটা, অথচ প্রতিটি order এখনো placed; মোট ৬৮,০৫৫ টাকা (৩৪৯ × ১৯৫, প্রতিটি ১৩৫ টাকার ডাল আর ঢাকার ৬০ টাকা delivery). Availability-র কোনো সংখ্যা এটি দেখাত না। এটিই পর্ব ৫৭-এর ছবির সেই B বিন্দু, এবার load-এর মধ্যে, শয়ে শয়ে। একই Idempotency-Key দিয়ে আবার চেষ্টা নিরাপদ (gateway key দেখে আগের charge চেনে), কিন্তু ক্রেতা চলে গেলে আবার চেষ্টা আসবেই না। তাই উত্তর হারানোর পরে নিয়মিত reconciliation লাগে, আর experiment-এর hypothesis-এ correctness-এর একটি শর্ত সবসময় রাখুন।

৭ · Experiment ৪ — load চলার সময় process kill

পর্ব ৫৭-এ একটি payment-এর মাঝে, শান্ত অবস্থায়, একবার kill করেছিলেন। এবার প্রশ্ন load-এর: ২০ জন user চলার সময় app-এর process মারা গেলে কতগুলো journey ব্যর্থ হয়, কত দ্রুত সাফল্য ফেরে, আর পরে টাকার হিসাব ঠিক থাকে কি? Hypothesis: crash-এর পরে ১০ সেকেন্ডের মধ্যে সাফল্য আবার ৯৯%-এর ওপরে; কোনো order-এ ভুল বা দ্বিগুণ charge নেই। Script ১০ সেকেন্ডে নিজের app-এর PID ধরে taskkill /PID … /F দেয়, আর সঙ্গে সঙ্গে একটি “supervisor”-এর মতো আবার চালু করে। সত্যিকারের আউটপুট:

[kill] users=20 journeys=1534 judged=all success=97.4% p95=408 ms
  errors: {'search:ReadError': 33, 'pay:RemoteProtocolError': 2,
           'cart:RemoteProtocolError': 2, 'order:RemoteProtocolError': 2,
           'search:RemoteProtocolError': 1}
killed at 10.1 s, health ok again at 10.7 s
failures from 10.0 s to 10.3 s; first success after 0.9 s
   0-5  s  journeys=333  ok=100%  users=20
   5-10 s  journeys=423  ok=97%  users=20
  10-15 s  journeys=191  ok=85%  users=20
  15-20 s  journeys=191  ok=100%  users=20
  20-25 s  journeys=187  ok=100%  users=20
  25-30 s  journeys=199  ok=100%  users=20
orders left 'placed': {'cash': 2, 'mobile-wallet': 1}
charged but unpaid: 0
orders with 2+ charges: 0
integrity: ok

(Cash আর wallet-এর আলাদা লাইন আর hypothesis-এর লাইন বাদ, error-এর লম্বা লাইন ভাঙা। Load-এর ঘড়ি kill-এর script-এর ঘড়ির একটু পরে শুরু, তাই “১০.০ s”-এর ব্যর্থতা ৫–১০ সেকেন্ডের ঘরেও কিছু পড়েছে।) ব্যর্থতা মোট ৪০টি, সবই ০.৩ সেকেন্ডের একটি জানালায়, আর প্রথম ব্যর্থতার ০.৯ সেকেন্ড পরে আবার সফল journey. ১৫ সেকেন্ডের পর থেকে প্রতিটি ঘরে ১০০%; ফেরার দাবি টিকেছে। পুরো run-এর সাফল্য ৯৭.৪%, সীমার নিচে, তাই সামগ্রিক দাবি ভাঙা; এখানে প্রশ্নটি নীতির: একটি crash কতটুকু error budget খেতে পারে? Charge-এর হিসাব পরিষ্কার: ভুল বা দ্বিগুণ charge শূন্য, database অক্ষত। তবে তিনটি order placed অবস্থায় আটকে আছে: crash-এর মুহূর্তে order তৈরি হয়েছিল, pay হয়নি। এরা স্টক ধরে রাখে; অপরিশোধিত order কখন নিজে বাতিল হবে, তার নিয়ম নেই। পর্ব ৫৭-এ তোলা requirement-এর ফাঁকটি এখানে load-এর মধ্যে আবার দেখা দিল।

আরেকটি জিনিস চোখে পড়বে: kill-এর আগে প্রতি ৫ সেকেন্ডে ৩৩৩–৪২৩টি journey, পরে ১৮৭–১৯৯টি। Restart কি app-কে ধীর করল? এর উত্তর দিতে kill ছাড়া, ঠিক পরেই, একই database-এ একটি control run চালানো হলো:

[control] users=20 journeys=981 judged=all success=100.0% p95=544 ms
control per 5 s: [158, 188, 149, 153, 151, 168]

Kill ছাড়াও হার একই নিচু স্তরে। অর্থাৎ পতনটি restart-এর ফল বলে দাবি করার ভিত্তি নেই; প্রথম ১০ সেকেন্ড কেন দ্রুত ছিল, এই ল্যাবে নিশ্চিত হওয়া যায়নি (যন্ত্রটিতে একই সময়ে অন্য কাজও চলছিল, আর database প্রতি run-এ বড় হচ্ছিল)। Control না থাকলে একটি ভুল finding লেখা হতো। ফেরার সময় মাপার পদ্ধতি আর MTTR-এর হিসাব পর্ব ৫৭-এ; recovery testing-এর এই load-সংস্করণ সেই সংখ্যাকে বাস্তবের কাছাকাছি আনে।

৮ · সুরক্ষার কোড নিজেই test — retry, backoff আর circuit breaker

Retry দেখতে নিরীহ: একবার না হলে আবার চেষ্টা। কিন্তু অনেক client একসাথে retry করলে ব্যর্থ dependency-র ওপর ভার কয়েক গুণ হয়, আর তা সেরে ওঠার পরেও ভিড় থেকে যায়: retry storm. নিচের সরল মডেলে প্রতি tick-এ ১০০টি নতুন অনুরোধ, dependency-র ক্ষমতা tick-প্রতি ১৫০, আর tick ২০ থেকে ২৯ পুরো বন্ধ (ইচ্ছাকৃত fault). চারটি নীতি: retry নেই; সঙ্গে সঙ্গে retry (সর্বোচ্চ তিনবার); exponential backoff আর jitter-সহ retry; আর তার সাথে circuit breaker. Random-এর seed দেওয়া, তাই প্রতিবার একই ফল। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import random


def simulate(policy, seed=1, users=100, cap=150, ticks=60):
    rng = random.Random(seed)
    later = {}                                   # tick -> retries due then
    sent = peak = ok = 0
    calm, open_until = None, -1
    for t in range(ticks):
        down = 20 <= t < 30                      # injected outage: ticks 20-29
        calls = [0] * users + later.pop(t, [])
        failed = 0
        if policy == "breaker" and t < open_until:
            failed, calls = len(calls), []       # open: reject at once, send nothing
        sent += len(calls)
        peak = max(peak, len(calls))
        for i, n in enumerate(calls):            # n = tries already made
            if down or i >= cap:                 # outage, or over capacity
                failed += 1
                if policy != "none" and n < 3:   # at most 3 retries
                    wait = 1 if policy == "retry" else rng.randint(1, 2 ** (n + 1))
                    later.setdefault(t + wait, []).append(n + 1)
            else:
                ok += 1
        if policy == "breaker" and calls and failed / len(calls) > 0.5:
            open_until = t + 3                   # open for 3 ticks, then try again
        if t >= 30 and calm is None and failed == 0:
            calm = t - 30
    return sent, peak, ok / (users * ticks), calm


print("policy    sent  peak/tick  success  calm after outage")
for p in ("none", "retry", "backoff", "breaker"):
    sent, peak, rate, calm = simulate(p)
    print(f"{p:<8} {sent:>5}  {peak:>9}  {rate:>7.1%}  {calm} ticks")

আসল আউটপুট:

policy    sent  peak/tick  success  calm after outage
none      6000        100    83.3%  0 ticks
retry     8850        400    85.0%  2 ticks
backoff   8971        386    92.2%  8 ticks
breaker   5200        100    80.0%  2 ticks

দশ tick-এর outage-এ retry ছাড়া ১০০০টি অনুরোধ হারায়, ৮৩.৩%. সঙ্গে সঙ্গে retry-তে লাভ মাত্র ১.৭ শতাংশ বিন্দু, কারণ তিনটি চেষ্টাই outage-এর ভেতরে পড়ে, অথচ dependency-র ওপর tick-প্রতি ভার ৪০০, স্বাভাবিকের চারগুণ: ১০০ নতুন আর আগের তিন tick-এর ৩০০ retry. Backoff আর jitter retry-গুলোকে পরের সময়ে ছড়ায়, তাই অনেকগুলো outage-এর পরে সফল হয় (৯২.২%); দাম হলো outage শেষে নতুন আর জমা retry মিলে ক্ষমতা ছাড়ায়, আর পুরো শান্ত হতে ৮ tick লাগে। এটি ছোট আকারে metastable failure-এর চেহারা: কারণ সরে গেলেও বাড়তি ভার ব্যর্থতা টেনে চলে। Circuit breaker সবচেয়ে কম পাঠায় (৫২০০), চূড়াও ১০০-তে বাঁধা, কিন্তু সাফল্য সবচেয়ে কম, কারণ খোলা অবস্থায় outage-এর পরের দুই tick-এর অনুরোধও সঙ্গে সঙ্গে ফিরিয়ে দেয়। কোনো নীতি সব দিকে সেরা নয়; dependency কতটা ভার সইতে পারে আর ব্যবহারকারীর কাছে কী জরুরি, তা দেখে বেছে নিতে হয়, আর বেছে নেওয়ার পরে fault ঢুকিয়ে যাচাই করতে হয়। মডেলটি সরল (half-open-এ একটি trial নয়, পুরো traffic ফেরে), সংখ্যা নয়, প্রবণতাটি শিক্ষা।

এবার একটি ছোট circuit breaker, যা বাজারঘরের wallet-এর ডাক পাহারা দেবে বলে লেখা। নকশা: পরপর তিনটি ব্যর্থতায় খোলে, ৩০ সেকেন্ড ডাকে না, তারপর half-open অবস্থায় একটি trial; trial ব্যর্থ হলে আবার পুরো ৩০ সেকেন্ড। ঘড়িটি নিজের হাতে, তাই সময় নিয়ন্ত্রিত। নিচের ব্লকটি breaker আর একটি ছোট প্রদর্শনী; পরের ব্লক একই namespace-এ test চালায়।

class Breaker:
    def __init__(self, clock, limit=3, cool=30):
        self.clock, self.limit, self.cool = clock, limit, cool
        self.state, self.fails, self.opened = "closed", 0, 0

    def call(self, fn):
        if self.state == "open":
            if self.clock() - self.opened < self.cool:
                raise RuntimeError("open: fail fast")   # wallet not called
            self.state = "half-open"                     # one trial call
        try:
            result = fn()
        except ConnectionError:
            self.fails += 1
            if self.fails >= self.limit:
                self.state, self.opened, self.fails = "open", self.clock(), 0
            elif self.state == "half-open":
                self.state = "open"
            raise
        self.state, self.fails = "closed", 0
        return result


def wallet_down():
    raise ConnectionError("wallet down")


now = 0
b = Breaker(lambda: now)                                 # a clock we control
for now in (0, 1, 2, 10, 32, 33):
    try:
        b.call(wallet_down)
    except Exception as e:
        print(f"t={now:>2}  {type(e).__name__:<15}  state={b.state}")

আসল আউটপুট:

t= 0  ConnectionError  state=closed
t= 1  ConnectionError  state=closed
t= 2  ConnectionError  state=open
t=10  RuntimeError     state=open
t=32  ConnectionError  state=open
t=33  ConnectionError  state=open

প্রথম চারটি লাইন নকশামতো। তিনটি ব্যর্থতায় খুলল, t=১০-এ wallet-কে না ডেকেই RuntimeError. t=৩২-এ ৩০ সেকেন্ড পেরিয়েছে, তাই একটি trial, যা ব্যর্থ। কিন্তু শেষ লাইনটি সন্দেহজনক: মাত্র এক সেকেন্ড পরে, t=৩৩-এ আবার ConnectionError, অর্থাৎ wallet-কে আবার ডাকা হয়েছে। নিচের stepper-এ কারণটি ধাপে ধাপে দেখুন।

1if state == "open":2  if now-opened < 30:3    raise fail fast4  state = "half-open"5wallet()  # fails6fails += 17if fails >= 3: open,8   opened=now, fails=09elif half-open: open
Breaker-এর ভেতরে
t
state
fails
opened
  1. t=০, প্রথম ব্যর্থতা। Breaker বন্ধ (closed), তাই wallet ডাকা হলো, ব্যর্থ। fails হলো ১. Caller পেল আসল ConnectionError.
  2. t=১, দ্বিতীয় ব্যর্থতা। একই পথ, fails ২. এখনো সীমার নিচে।
  3. t=২, তৃতীয় ব্যর্থতা: খুলল। fails ৩ হতেই অবস্থা open, opened = ২, আর গোনা আবার ০. এখন থেকে ৩০ সেকেন্ড wallet বিশ্রাম পাবে।
  4. t=১০: fail fast. ১০ − ২ = ৮, যা ৩০-এর কম, তাই wallet-কে না ডেকেই RuntimeError. এটিই breaker-এর আসল কাজ: ব্যর্থ dependency-র ওপর ভার শূন্য, caller সঙ্গে সঙ্গে উত্তর পায়।
  5. t=৩২: trial, আর গোপন bug. ৩২ − ২ = ৩০, বিরতি শেষ, তাই half-open আর একটি trial. Trial ব্যর্থ, fails ১, সীমার নিচে, তাই শেষ লাইনের elif: অবস্থা open. কিন্তু opened এখনো ২! নতুন খোলার সময় লেখা হয়নি।
  6. t=৩৩: বিরতি ছাড়াই আবার ডাক। ৩৩ − ২ = ৩১, যা ৩০-এর বেশি, তাই আবার half-open, আবার wallet ডাকা। এখন থেকে প্রতিটি ডাকই একটি “trial”: breaker খোলা দেখালেও ব্যর্থ wallet প্রতি সেকেন্ডে ভার পাচ্ছে, ঠিক যা ঠেকানোর জন্য breaker বানানো।

প্রদর্শনী দেখে সন্দেহ হলো; এবার requirement থেকে লেখা test, যাতে প্রমাণ থাকে আর ভবিষ্যতে ফিরে না আসে:

import sys, unittest


class BreakerTest(unittest.TestCase):
    def setUp(self):
        self.now, self.calls = 0, []
        self.b = Breaker(lambda: self.now)

    def pay(self, at, up=False):                         # one wallet call at time `at`
        self.now = at
        def wallet():
            self.calls.append(at)
            if not up:
                raise ConnectionError("wallet down")
            return "paid"
        try:
            return self.b.call(wallet)
        except (ConnectionError, RuntimeError) as e:
            return type(e).__name__

    def test_open_after_three_failures_fails_fast(self):
        [self.pay(0) for _ in range(3)]
        self.assertEqual(self.pay(10), "RuntimeError")
        self.assertEqual(self.calls, [0, 0, 0])          # 4th call never sent

    def test_trial_success_closes(self):
        [self.pay(0) for _ in range(3)]
        self.assertEqual((self.pay(30, up=True), self.b.state), ("paid", "closed"))

    def test_failed_trial_waits_full_cooldown_again(self):
        [self.pay(0) for _ in range(3)]
        self.pay(30)                                     # trial fails at t=30
        self.assertEqual(self.pay(31, up=True), "RuntimeError")
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(
    unittest.defaultTestLoader.loadTestsFromTestCase(BreakerTest))

আসল আউটপুট (traceback-এর মাঝের অংশ ছোট করা):

test_failed_trial_waits_full_cooldown_again (__main__.BreakerTest.test_failed_trial_waits_full_cooldown_again) ... FAIL
test_open_after_three_failures_fails_fast (__main__.BreakerTest.test_open_after_three_failures_fails_fast) ... ok
test_trial_success_closes (__main__.BreakerTest.test_trial_success_closes) ... ok

======================================================================
FAIL: test_failed_trial_waits_full_cooldown_again (__main__.BreakerTest.test_failed_trial_waits_full_cooldown_again)
----------------------------------------------------------------------
Traceback (most recent call last):
  …
AssertionError: 'paid' != 'RuntimeError'
- paid
+ RuntimeError

----------------------------------------------------------------------
Ran 3 tests in 0.001s

FAILED (failures=1)

দুটি test সবুজ: তিন ব্যর্থতায় খোলা আর ডাক না পাঠানো, আর সফল trial-এ বন্ধ হওয়া। তৃতীয়টি লাল: t=৩০-এ trial ব্যর্থ, আর মাত্র এক সেকেন্ড পরে breaker-এর fail fast করার কথা, অথচ wallet ডাকা হলো, আর এবার wallet সুস্থ থাকায় উত্তর এল “paid”. লক্ষ করুন, এই test-এ wallet সুস্থ রাখা হয়েছে ইচ্ছা করে: তাহলে ফল ভিন্ন হয়, আর bug-টি একটি স্পষ্ট মানে পায়। শুধু “state open কি না” দেখলে test ধরা পড়ত না, কারণ state ঠিকই open দেখায়। Fix এক লাইনের, অনুশীলন ৪-এ। এ ধরনের ভুল সাধারণ কাজের দিনে কোনো সমস্যা দেখায় না; শুধু dependency সত্যিই দীর্ঘ সময় বন্ধ থাকলে প্রকাশ পায়, তাই বলয় ১-এর test-ই এর সবচেয়ে সস্তা পাহারা।

আরও গভীরে: কোন fault ঢোকাবেন, তা এলোমেলো না বেছে যুক্তি দিয়ে খোঁজার একটি গবেষণা-ধারা আছে: Peter Alvaro ও সহকর্মীদের lineage-driven fault injection (২০১৫ সালের দিকে), যা একটি সফল ফলের পেছনের সব পথ খুঁজে এমন fault-এর জোড়া বাছে, যা সব পথ একসাথে ভাঙতে পারে; Netflix-এর সাথে এর প্রয়োগের কাজও প্রকাশিত হয়েছে বলে জানা যায়। অন্যদিকে ২০২১ সালের একটি গবেষণাপত্রে (Bronson ও সহকর্মীরা, HotOS) metastable failure-কে আলাদা শ্রেণি হিসেবে বর্ণনা করা হয়, যেখানে retry-র মতো “সুরক্ষা”-ই ব্যর্থতাকে টিকিয়ে রাখে। দুটিরই শিক্ষা: fault-এর তালিকা আর সুরক্ষার আচরণ, দুটিই পরিকল্পিত test-এর বিষয়।

পরীক্ষা ও ইন্টারভিউতে (বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন সাধারণ):

  • Chaos engineering আর সাধারণ load test-এর পার্থক্য? — Load test চাপ বাড়িয়ে ক্ষমতা মাপে; chaos experiment চাপ স্বাভাবিক রেখে একটি ব্যর্থতা ঢোকায় আর steady-state hypothesis টেকে কি না দেখে।
  • Steady-state hypothesis কী, উদাহরণ? — Fault-এর মধ্যেও ঠিক থাকবে এমন মাপা দাবি, যেমন “wallet ধীর হলেও cash checkout-এর সাফল্য ≥ ৯৯%, p95 ≤ ১ সেকেন্ড”.
  • Blast radius আর abort condition কেন? — ক্ষতির পরিধি ছোট রাখতে, আর সীমা পেরোলে সঙ্গে সঙ্গে থেমে rollback করতে।
  • Circuit breaker-এর তিন অবস্থা? — Closed (ডাক যায়), open (ডাক না পাঠিয়ে সঙ্গে সঙ্গে ব্যর্থ), half-open (বিরতির পরে অল্প trial; সফল হলে closed, ব্যর্থ হলে আবার পুরো বিরতির জন্য open).
  • Retry-তে jitter কেন? — সব client একই মুহূর্তে আবার চেষ্টা করলে নতুন ভিড় হয়; এলোমেলো দেরি সেই চেষ্টাগুলো সময়ে ছড়িয়ে দেয়।

৯ · AI-এর যুগে chaos আর resilience testing

AI সহকারীকে “আমার app-এর জন্য chaos test লিখে দাও” বললে চেনা ভুলগুলো আসে। Steady state হিসেবে শুধু /api/health 200 দেখে। Process মারতে pkill python বা taskkill /IM python.exe /F দেয়, যা কম্পিউটারের সব Python process মেরে ফেলে। কোনো abort condition নেই, rollback নেই, বা থাকলেও দাবি ভাঙলে তা চলে কি না দেখে না। Load দেয় শত শত user, আধা ঘণ্টা ধরে। Toxiproxy-র এমন toxic বা Chaos Toolkit-এর এমন option বানায়, যা নথিতে নেই। Server ফেরার অপেক্ষায় sleep(30). Wallet-কে এত mock করে যে lock-এর মতো আসল পথটিই test-এ থাকে না, ফলে E2-এর finding কখনো আসত না। প্রত্যাশা লেখে কোডের বর্তমান আচরণ থেকে, requirement থেকে নয়, তাই §৮-এর breaker-এর bug-কেই “সঠিক” ধরে নেয়। আর প্রায়ই না চালিয়েই লেখে “system resilient”.

AI-কে কাজ দেওয়ার সময় hypothesis, পরিধি আর থামার নিয়ম আগে থেকে দিয়ে দিন:

তুমি একজন QA engineer. বাজারঘর নামের একটি localhost app-এর জন্য একটি chaos experiment-এর পরিকল্পনা আর Chaos Toolkit-এর JSON লেখো। Steady-state hypothesis: "২০ জন user-এর load-এ wallet ১.৫ সেকেন্ড ধীর হলেও cash checkout-এর সাফল্য ≥ ৯৯% আর p95 ≤ ১০০০ ms; কোনো অপরিশোধিত order-এ টাকা কাটা থাকবে না।" শর্ত: ১. সব অনুরোধ শুধু 127.0.0.1-এ; load ৩০ জনের বেশি নয়, প্রতি probe ২ মিনিটের কম। ২. Process বন্ধ শুধু নিজের শুরু করা process-এর PID দিয়ে; নাম ধরে কোনো process মারবে না। ৩. একটি abort condition আর একটি rollback দাও, আর বলো দাবি ভাঙলেও rollback চলবে কীভাবে। ৪. Steady state-এ health endpoint নয়, ব্যবহারকারীর journey মাপো; correctness-এর জন্য database-এ order আর ledger মেলানোর query দাও। ৫. যে toxic, option বা flag-এর ব্যাপারে নিশ্চিত নও, বানিয়ে না লিখে আলাদা তালিকা দাও, যাতে আমি নথিতে মিলাই। ৬. চালানোর আগে "system resilient" বা "পাস করেছে" দাবি করবে না।

AI-এর লেখা chaos experiment বা resilience test হাতে পেলে — চেকলিস্ট

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

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

প্র ০১Netflix কেন ইচ্ছা করে production-এ server বন্ধ করত? একজন tester কি তাহলে কাল থেকেই production-এ chaos চালাবেন?

Netflix-এর যুক্তি প্রকাশ্যে বহুবার বলা হয়েছে: cloud-এ চলে যাওয়ার পরে একটি server হারানো কোনো দূরের ঝুঁকি নয়, নিয়মিত ঘটনা। ঘটনাটি ঘটবেই; প্রশ্ন শুধু কখন। রাত তিনটায়, যখন কেউ জেগে নেই, নাকি দুপুরে, যখন সব প্রকৌশলী অফিসে আর dashboard-এর দিকে তাকিয়ে? Chaos Monkey কাজের সময়ে এলোমেলো server বন্ধ করে প্রথমটিকে দ্বিতীয়টিতে বদলেছিল। তার চেয়েও বড় ফল ছিল নকশায়: প্রতিটি দল জানত তাদের server যেকোনো দিন মরবে, তাই একটি server-এর ওপর নির্ভর না করা আর redundancy রাখা আলাদা নিয়ম হিসেবে বলতে হতো না।

কিন্তু এর পেছনে কয়েক বছরের প্রস্তুতি ছিল: স্বয়ংক্রিয় deploy, ভালো monitoring, দ্রুত rollback, আর এমন একটি সংস্কৃতি, যেখানে experiment-এ দুর্বলতা পাওয়াকে সাফল্য ধরা হয়, কারও দোষ নয়। সেগুলো ছাড়া production-এ fault ঢোকানো মানে শুধু একটি বিভ্রাট তৈরি করা, যার ফল কেউ মাপতেও পারবে না। Principles of Chaos-এর লেখাতেও blast radius ছোট রাখার কথা স্পষ্ট।

একজন tester-এর জন্য বাস্তব পথটি এই পর্বের বলয়গুলোর মতো। প্রথমে কোডের ভেতরে, নকল ঘড়ি আর নকল dependency দিয়ে; তারপর নিজের ল্যাবে, নিজের কপিতে, ছোট load-এ। বাজারঘরের E2-এর finding (ধীর wallet-এ cash checkout আটকানো) ল্যাবেই পাওয়া গেছে, production-এর একজন ক্রেতাকেও কষ্ট না দিয়ে। Staging-এ যাওয়ার আগে ল্যাবের সব জানা দুর্বলতা সারানো দরকার, আর production-এর ছোট অংশে যাওয়ার আগে লাগে অনুমতি, abort condition-এর স্বয়ংক্রিয় ব্যবস্থা আর on-call মানুষ।

আরেকটি কথা: production-এ chaos না চালালেও chaos-এর চিন্তা কাজে লাগে। প্রতিটি নতুন feature-এর test plan-এ একটি প্রশ্ন যোগ করুন: “এর dependency ধীর হলে, বন্ধ হলে, বা উত্তর হারালে কী হবে, আর সেটি কে মাপবে?”

মূল উপলব্ধি: Production-এ chaos হলো একটি পরিণত দলের শেষ ধাপ, শুরু নয়; tester শুরু করেন সবচেয়ে ছোট বলয়ে, আর প্রতিটি বলয়ে শেখা দুর্বলতা সারিয়ে তবেই পরিধি বাড়ান।

প্র ০২২০১৭ সালের একটি বড় cloud storage বিভ্রাট শুরু হয়েছিল একটি command-এ ভুল input থেকে। Blast radius আর recovery test নিয়ে এটি কী শেখায়?

২০১৭ সালের ফেব্রুয়ারির শেষে AWS-এর একটি region-এ S3 storage service কয়েক ঘণ্টা ব্যাহত হয়, আর তার ওপর নির্ভরশীল বহু website ও service-ও সমস্যায় পড়ে। AWS-এর প্রকাশিত সারাংশ অনুযায়ী, একজন প্রকৌশলী একটি নির্ধারিত পদ্ধতি মেনে কিছু server সরানোর command চালাচ্ছিলেন, কিন্তু input-এর একটি ভুলে প্রত্যাশার চেয়ে অনেক বেশি server সরে যায়, যার মধ্যে দুটি গুরুত্বপূর্ণ ভেতরের subsystem-এর অংশ ছিল। এরপর সেগুলো পুরোপুরি restart করতে হয়, আর সারাংশে স্বীকার করা হয় যে বড় region-গুলোতে এই subsystem-গুলো বহু বছর পুরোপুরি restart করা হয়নি; ফলে restart আর যাচাইয়ে প্রত্যাশার চেয়ে বেশি সময় লেগেছিল। এমনকি service-এর অবস্থা দেখানোর dashboard-ও শুরুতে ঠিকমতো হালনাগাদ করা যায়নি, কারণ সেটি নিজেই আক্রান্ত storage-এর ওপর নির্ভর করত।

Tester-এর জন্য তিনটি শিক্ষা। প্রথম, blast radius শুধু chaos experiment-এর বিষয় নয়, প্রতিটি operational টুলের। একটি command সর্বোচ্চ কতটুকু ক্ষমতা সরাতে পারে, তার সীমা থাকা উচিত, আর সেই সীমা test হওয়া উচিত: ইচ্ছা করে বড় একটি মান দিয়ে দেখা টুলটি আটকায় কি না। প্রকাশিত সারাংশেও এমন সুরক্ষা যোগের কথা বলা হয়েছিল।

দ্বিতীয়, যে recovery পথ বহু বছর চলেনি, তা আসলে অপরীক্ষিত। এই পর্বের E4-এ ছোট app ০.৬ সেকেন্ডে ফিরেছে, কারণ database ছোট আর restart প্রতিদিনের কাজ। বড় system-এ পূর্ণ restart বিরল, তাই তার সময় কেউ জানে না। নিয়মিত recovery drill, অর্থাৎ বাস্তব আকারে restart করে সময় মাপা, এই অজানাকে সংখ্যায় আনে।

তৃতীয়, লুকানো নির্ভরতা: যে dashboard দিয়ে বিভ্রাটের খবর দেওয়া হবে, সেটিই একই জিনিসের ওপর নির্ভর করলে ঠিক দরকারের মুহূর্তে অন্ধ। Experiment-এর পরিকল্পনায় জিজ্ঞেস করুন, monitoring, alert আর rollback-এর পথ নিজেই আক্রান্ত অংশের ওপর নির্ভর করে কি না।

মূল উপলব্ধি: ক্ষতির পরিধি সীমিত রাখার সুরক্ষা আর বিরল recovery পথ, দুটিই নিয়মিত test না করলে প্রয়োজনের দিনে অজানা আচরণ করে।

প্র ০৩Fault সরে গেল, তবু system সেরে উঠছে না — এমন কীভাবে হয়, আর tester কীভাবে ধরবেন?

স্বাভাবিক ধারণা হলো, কারণ সরলে ফলও সরে। কিন্তু অনেক বড় বিভ্রাটে দেখা গেছে উল্টোটা: শুরুর কারণ (একটি ধীর database, একটি ছোট network সমস্যা) কয়েক মিনিটে মিটে গেছে, অথচ system ঘণ্টাখানেক ধরে খারাপ অবস্থায় আটকে থেকেছে। ২০২১ সালে Bronson ও সহকর্মীদের একটি গবেষণাপত্র (HotOS সম্মেলনে) এই ধরনকে “metastable failure” নাম দেয়: system-এর দুটি স্থির অবস্থা আছে, একটি সুস্থ, একটি অসুস্থ, আর একটি ধাক্কা তাকে দ্বিতীয়টিতে ফেলে দিলে কিছু প্রতিক্রিয়া নিজেরাই সেখানে আটকে রাখে।

সেই প্রতিক্রিয়ার সবচেয়ে পরিচিত উৎস retry. Dependency ধীর হলে client-এর timeout হয়, client আবার পাঠায়, ভার বাড়ে, dependency আরও ধীর হয়, আরও timeout. এই পর্বের simulation-এ ছোট আকারে দেখেছেন: সঙ্গে সঙ্গে retry-তে ভার চারগুণ, আর backoff-এর ক্ষেত্রেও outage শেষে জমে থাকা retry আট tick ধরে ক্ষমতা ছাপিয়েছে। বাস্তবে আরও উৎস আছে: cache খালি হয়ে যাওয়ায় সব অনুরোধ database-এ যাওয়া, জমে থাকা কাজের সারি, বা restart-এর পরে সব client একসাথে ফিরে আসা।

Tester-এর ধরার উপায় experiment-এর নকশায়। প্রথম, hypothesis-এ শুধু “fault চলার সময়” নয়, “fault সরানোর পরে কত সময়ে স্বাভাবিক” রাখুন, যেমন E4-এ crash-এর পরের ১০ সেকেন্ড। দ্বিতীয়, rollback-এর পরেও মাপা চালিয়ে যান; Chaos Toolkit-এর আগে-পরে probe-এর পাশাপাশি rollback-এর পরে আরেকটি probe রাখা যায়। তৃতীয়, load-এর আকার বাস্তবের কাছাকাছি রাখুন: একেবারে ছোট load-এ এই চক্র তৈরিই হয় না, আর closed load-এ ভিড় নিজে থেকে কমে যায়, যা §৫-এ দেখেছেন। চতুর্থ, retry-র সংখ্যা, retry-র বাজেট (যেমন মোট অনুরোধের নির্দিষ্ট শতাংশের বেশি retry নয়) আর breaker-এর আচরণকে আলাদা metric হিসেবে দেখুন।

মূল উপলব্ধি: সুরক্ষার কৌশলই ব্যর্থতাকে টিকিয়ে রাখতে পারে; তাই fault সরানোর পরের সময়টিও hypothesis-এর অংশ, আর retry-র ভার আলাদা করে মাপার বিষয়।

প্র ০৪Staging-এ সব experiment সবুজ, তবু production-এ একই ধরনের ব্যর্থতায় বিপদ — game day আর বিপর্যয়-মহড়া এখানে কী যোগ করে?

Staging যত যত্নেই বানানো হোক, তিনটি জিনিস সাধারণত মেলে না: data-র আকার ও ধরন, traffic-এর মিশ্রণ, আর মানুষ। তৃতীয়টি সবচেয়ে কম আলোচিত। একটি বিভ্রাটে কে alert পাবেন, তিনি runbook খুঁজে পাবেন কি না, runbook-এর command এখনো চলে কি না, কে সিদ্ধান্ত নেবেন আর গ্রাহকদের কে জানাবেন, এগুলো কোনো automated experiment দেখায় না।

এজন্য বড় প্রতিষ্ঠানগুলো পরিকল্পিত মহড়া চালায়। Amazon-এ ২০০০-এর দশকে “GameDay” নামের অনুশীলনের কথা প্রকাশ্যে বলা হয়েছে, যার পেছনে অগ্নিনির্বাপণ প্রশিক্ষণের অভিজ্ঞতা ছিল বলে জানা যায়; Google-এ DiRT (Disaster Recovery Testing) নামের বার্ষিক কর্মসূচির কথাও তাদের প্রকৌশলীদের লেখায় এসেছে, যেখানে একটি পুরো data center বা গুরুত্বপূর্ণ মানুষ “অনুপস্থিত” ধরে কাজ চালানো অনুশীলন করা হয়। এসব মহড়ায় প্রায়ই প্রযুক্তির চেয়ে প্রক্রিয়ার দুর্বলতা বেশি ধরা পড়ে: পুরোনো ফোন নম্বর, অনুমতির অভাব, এমন একটি ধাপ যা শুধু একজনই জানেন।

একটি game day-এর কাঠামো এই পর্বের experiment-এর মতোই, শুধু hypothesis-এ মানুষের অংশ যোগ হয়: “wallet বন্ধ হলে ৫ মিনিটের মধ্যে alert আসবে, on-call ব্যক্তি ১৫ মিনিটের মধ্যে ক্যাশ-ভিত্তিক বিকল্প চালু করবেন, আর ক্রেতারা checkout-এ একটি স্পষ্ট বার্তা দেখবেন।” Tester-এর ভূমিকা: দৃশ্যপট লেখা, abort condition ঠিক করা, সময় আর ঘটনা লিপিবদ্ধ করা, আর শেষে finding-গুলোকে টিকিট বানানো, ঠিক একটি bug report-এর মতো স্পষ্ট করে।

Staging-এর সবুজ ফলকে তাই একটি সীমিত দাবি হিসেবে পড়ুন: “এই পরিবেশে, এই load-এ, এই fault-এ টেকে।” Production-এর ঝুঁকি কমাতে লাগে বাস্তবের মতো data-র কপি, পর্যবেক্ষণ, আর মানুষসহ মহড়া।

মূল উপলব্ধি: Resilience শুধু কোডের গুণ নয়, কোড, পরিবেশ আর মানুষের মিলিত গুণ; game day সেই তৃতীয় অংশটিকে test-এর আওতায় আনে।

প্র ০৫“System চালু আছে” কি resilience-এর যথেষ্ট প্রমাণ? Correctness-কে hypothesis-এ রাখা কেন জরুরি?

E3-এর ফলটি আবার দেখুন। Availability-র চোখে ছবিটি খারাপ নয়: app চালু, cash ১০০%, wallet-এর ব্যর্থতা দ্রুত আর পরিষ্কার 504. অথচ database মেলাতেই বেরোল ৩৪৯টি order-এ টাকা কাটা, যেগুলো অপরিশোধিত। ক্রেতার চোখে এটিই সবচেয়ে খারাপ ব্যর্থতা: টাকা গেল, পণ্য আসবে না।

Distributed system-এর জগতে এই শিক্ষার সবচেয়ে পরিচিত উৎস Jepsen নামের স্বাধীন প্রকল্প, যা Kyle Kingsbury ২০১৩ সালের দিকে শুরু করেন। এর পদ্ধতি এই পর্বের মতোই, শুধু অনেক গভীরে: একটি database-এর কয়েকটি node-এ load চালানো, মাঝে network বিচ্ছিন্ন করা, process মারা, ঘড়ি সরানো, তারপর পুরো ইতিহাস বিশ্লেষণ করে দেখা কোনো লেখা হারিয়েছে কি না, বা database তার নথিতে যে নিশ্চয়তা দাবি করে, তা ভেঙেছে কি না। বহু রিপোর্টে দেখা গেছে, system চালু ছিল, উত্তরও দিচ্ছিল, কিন্তু নিশ্চিত হয়েছে বলা কিছু লেখা পরে আর পাওয়া যায়নি।

তাই একটি ভালো steady-state hypothesis-এর দুটি অংশ থাকে। Liveness-এর অংশ: অনুরোধ সফল হচ্ছে, সময়মতো হচ্ছে। Safety-র অংশ: যা হচ্ছে, তা সঠিক; কোনো টাকা দুবার কাটা হয়নি, কোনো order হারায়নি, স্টক ঋণাত্মক হয়নি, ledger আর order মেলে। দ্বিতীয় অংশের জন্য লাগে experiment-এর পরে database বা ledger থেকে invariant যাচাই, ঠিক যেভাবে প্রতিটি run-এর পরে এই পর্বে করা হয়েছে। Load script-এর নিজের হিসাবের ওপর ভরসা করবেন না; সে শুধু জানে কী উত্তর পেয়েছে, ভেতরে কী ঘটেছে তা নয়।

মূল উপলব্ধি: “চালু আছে” মানে শুধু liveness; resilience-এর আসল প্রমাণ আসে যখন fault-এর পরেও data-র invariant টেকে, আর তা যাচাই হয় system-এর ভেতরের হিসাব থেকে।

অনুশীলন

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

  1. Spec থেকে experiment (test design): Requirement R-9: “Wallet gateway ২ সেকেন্ডের বেশি দেরি করলে app ৩ সেকেন্ডের মধ্যে ক্রেতাকে ‘পরে আবার চেষ্টা করুন’ দেখাবে; এই সময়ে cash checkout-এর p95 ১ সেকেন্ডের নিচে থাকবে; কোনো order-এ দুবার টাকা কাটবে না।” এর জন্য experiment-এর একটি সেট বানান: hypothesis, কোন fault কোন মানে, blast radius, abort condition আর প্রতিটির প্রত্যাশিত ফল।

    Hypothesis: ২০ জন user-এ (অর্ধেক cash), (ক) cash journey-র সাফল্য ≥ ৯৯% আর p95 < ১০০০ ms; (খ) wallet-এর প্রতিটি উত্তর ৩ সেকেন্ডের মধ্যে, হয় সফল নয়তো “পরে চেষ্টা করুন”; (গ) run-এর পরে ledger-এ কোনো order-এর দুটি charge নেই, আর charge আছে এমন প্রতিটি order paid বা reconciliation-এর তালিকায়।

    Fault-এর মান সীমানা ধরে (পর্ব ০৮-এর BVA): wallet-এর দেরি ১৯০০ ms (দুই সেকেন্ডের নিচে: সাধারণ সফল payment প্রত্যাশিত), ২১০০ ms (ওপরে: “পরে চেষ্টা করুন”, আর তা ৩ সেকেন্ডের মধ্যে), আর ১০,০০০ ms (খুব বেশি: উত্তর তবু ৩ সেকেন্ডে, অর্থাৎ app-এর নিজের timeout আছে কি না যাচাই)। ঠিক ২০০০ ms-এ আচরণ requirement-এ অস্পষ্ট (“বেশি”), তাই আলাদা প্রশ্ন হিসেবে তুলুন, আর jitter-এর কারণে সীমানার মান যথেষ্ট দূরে রাখুন। সাথে timeout_once mode: একই Idempotency-Key-এ দ্বিতীয় চেষ্টায় ঠিক একটি charge.

    Blast radius: নিজের localhost, নিজের database, বানানো user. Abort: শেষ ১০ সেকেন্ডে cash-এর সাফল্য ৫০%-এর নিচে। Rollback: app আবার দেরি ছাড়া চালু, wallet mode success. প্রত্যাশা: এই পর্বের মূল app-এ (ক) ২১০০ ms-এ ভাঙবে, কারণ lock-এর ভেতরে wallet-এর ডাক; fix-করা কপিতে টেকার কথা। (খ)-এর জন্য app-এ wallet-এর ডাকে timeout নেই, তাই ১০,০০০ ms-এ ভাঙবে, এটি একটি নতুন finding হবে।

  2. Failure পড়ুন: একটি experiment-এর আউটপুট: cash n=22 ok=13.6% p95=5070 ms, errors: {'cart:ReadTimeout': 24, 'pay:ReadTimeout': 14}, ABORT at 10 s. Fault ছিল শুধু wallet-এ ১৫০০ ms দেরি। কোন তিনটি তথ্য বলে যে সমস্যা wallet-এর সীমানা ছাড়িয়ে গেছে, আর আপনি bug report-এ কী লিখবেন?

    তিনটি তথ্য: (১) cash journey-র সাফল্য ১৩.৬%, অথচ cash-এ wallet ডাকাই হয় না; (২) সবচেয়ে বেশি timeout cart ধাপে, যা wallet-এর আগের ধাপ আর wallet-এর সাথে সম্পর্কহীন; (৩) cash-এর p95 ৫০৭০ ms, client-এর ৫ সেকেন্ডের timeout-এর গায়ে, অর্থাৎ অনুরোধগুলো কাজ না করে কোথাও অপেক্ষায় ছিল। তিনটি মিলে বলে, wallet-এর ধীরতা একটি ভাগ করা সম্পদ (এখানে global write lock) আটকে রেখেছে।

    Bug report: শিরোনাম “Wallet gateway ধীর হলে cash checkout-সহ সব লেখার কাজ timeout হয়”। পুনরুৎপাদন: BAZARGHAR_WALLET_DELAY_MS=1500, ২০ জন user, অর্ধেক cash. প্রত্যাশিত: cash p95 < ১০০০ ms, সাফল্য ≥ ৯৯%. প্রকৃত: উপরের সংখ্যা, abort ১০ সেকেন্ডে। সম্ভাব্য কারণ (যাচাইসহ): pay-এ wallet-এর ডাক write lock ধরে রেখে হয়। প্রমাণ: lock-এর বাইরে আনা কপিতে একই experiment-এ cash ১০০%, p95 ৪৭৮ ms. তীব্রতা: উচ্চ, কারণ একটি dependency-র ধীরতা পুরো দোকান বন্ধ করে।

  3. Experiment-এর ভুল খুঁজুন: একজন সহকর্মী এই পরিকল্পনা দিলেন: “Steady state: GET /api/health 200. Fault: taskkill /IM python.exe /F. Load: ৫০০ জন user, ৩০ মিনিট, শেয়ার করা test server-এ। Rollback: দরকার নেই, app তো আবার চালু হবে। দাবি ভাঙলে রিপোর্ট লিখব।” অন্তত পাঁচটি সমস্যা বের করুন।
    • Steady state ভুল মাপ: health endpoint ব্যবহারকারীর অভিজ্ঞতা দেখায় না; journey-র সাফল্য, p95, throughput আর টাকার হিসাব লাগবে।
    • নাম ধরে kill: কম্পিউটারের সব Python process মরবে, অন্যের কাজসহ; শুধু নিজের শুরু করা process-এর PID.
    • Blast radius বড় আর অনুমতিহীন: শেয়ার করা server-এ ৫০০ জন user ৩০ মিনিট অন্য দলের কাজ নষ্ট করবে; নিজের কপি, ছোট load, অল্প সময়।
    • Abort condition নেই: কখন থামবেন, আগে থেকে লেখা নেই।
    • Rollback নেই, আর “আবার চালু হবে” একটি অনুমান: কে চালু করবে, কত সময়ে, আর data ঠিক আছে কি না, এগুলোই তো যাচাইয়ের বিষয়।
    • Hypothesis-এ সংখ্যা আর correctness নেই: “দাবি ভাঙলে” বলতে কী, তা অস্পষ্ট; control run-ও নেই।
  4. আউটপুট অনুমান করুন আর fix করুন: §৮-এর breaker-এর elif self.state == "half-open":-এর নিচের লাইনটি বদলে লেখা হলো self.state, self.opened, self.fails = "open", self.clock(), 0. এখন প্রদর্শনী ব্লকের শেষ দুই লাইন (t=৩২ আর t=৩৩) কী ছাপবে, আর তিনটি test-এর ফল কী হবে? আগে অনুমান লিখুন, তারপর ব্লকে বদলে চালিয়ে মিলিয়ে দেখুন।

    t=৩২: ConnectionError state=open (trial ব্যর্থ, এবার opened = ৩২)। t=৩৩: RuntimeError state=open, কারণ ৩৩ − ৩২ = ১, যা ৩০-এর কম; wallet ডাকা হয় না। এই ল্যাবে বদলানো কোড চালিয়ে ঠিক এই দুই লাইনই পাওয়া গেছে, আর test চালালে তিনটিই ok, শেষে OK. শিক্ষা: “খোলা” অবস্থায় প্রবেশের প্রতিটি পথ একই কাজ করবে (সময় লেখা, গোনা শূন্য)। দুটি জায়গায় একই কাজ লেখা থাকলে একটি ভুলে যাওয়া সহজ; একটি _open() method বানিয়ে দুই জায়গা থেকে ডাকলে এ ধরনের ভুলের সুযোগ কমে।

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

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

ক্রমএকটি chaos experiment-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. 📏 Fault ছাড়া স্বাভাবিক অবস্থা মাপা
  2. ✍️ Hypothesis আর abort condition লেখা
  3. 🎯 ছোট blast radius বাছা আর rollback তৈরি রাখা
  4. ⚡ Load চলা অবস্থায় fault ঢুকিয়ে মাপা
  5. ⚖️ Control-এর সাথে মিলিয়ে রায় দেওয়া
  6. 🔁 Rollback, দুর্বলতার fix, তারপর একই experiment আবার

একটি online দোকানের wallet dependency নিয়ে experiment. নিচের কোনটি সবচেয়ে ভালো steady-state hypothesis?

  • Fault-এর সময় /api/health 200 দেবে
  • Fault-এর সময় server-এর CPU ৫০%-এর নিচে থাকবে
  • Wallet ১.৫ সেকেন্ড ধীর হলেও ২০ জন user-এ cash checkout-এর সাফল্য ≥ ৯৯%, p95 ≤ ১০০০ ms, আর অপরিশোধিত কোনো order-এ টাকা কাটা নেই
  • Fault-এর পরেও system-এ কোনো bug থাকবে না

Chaos Toolkit 1.21-এ একটি experiment-এর method-এর পরের steady-state probe নিজেই error দিয়ে ব্যর্থ হলো, অর্থাৎ status failed. Command-এ কোনো rollback strategy দেওয়া হয়নি। Toolkit-এর নিজের সাহায্য-বার্তা অনুযায়ী কী ঘটবে?

  • Rollback সবসময় চলবে, তাই fault নিজে থেকে সরবে
  • ডিফল্টে rollback চলবে না; fault সরাতে --rollback-strategy always দিতে হতো
  • Toolkit নিজে থেকে experiment আবার শুরু করবে
  • Method-এর action বাতিল হয়ে যাবে, কারণ দাবি ভেঙেছে

Payment gateway ধীর করার experiment-এ দেখা গেল ক্যাশে পে করা ক্রেতাদের cart-এ পণ্য যোগ করাও timeout হচ্ছে। সবচেয়ে সম্ভাব্য নকশাগত কারণ কোনটি?

  • Gateway-এর কোডে একটি গণনার ভুল
  • Client-এর timeout খুব ছোট
  • ক্রেতাদের network ধীর
  • Gateway-এর ডাক একটি ভাগ করা lock বা সম্পদ ধরে রেখে হয়, তাই বাকি সব কাজ সারিতে আটকে থাকে

প্রতি সেকেন্ডে ১০০টি নতুন অনুরোধ আসে, আর প্রতিটি client ব্যর্থ হলে পরের সেকেন্ডেই আবার চেষ্টা করে, সর্বোচ্চ তিনবার। Dependency কয়েক সেকেন্ড পুরো বন্ধ থাকলে কিছুক্ষণ পরে তার ওপর প্রতি সেকেন্ডে কতগুলো অনুরোধ যাবে?

  • ৪০০টি
  • ১০০টি
  • ২০০টি
  • প্রতি সেকেন্ডে বাড়তেই থাকবে, কোনো সীমা নেই

একটি circuit breaker ৩০ সেকেন্ড খোলা থাকার পরে half-open অবস্থায় একটি trial পাঠাল, আর trial ব্যর্থ হলো। সঠিক আচরণ কোনটি?

  • Half-open থেকে যাওয়া, আর পরের প্রতিটি ডাককে trial হিসেবে পাঠানো
  • আবার open, আর ব্যর্থতার মুহূর্ত থেকে আবার পুরো ৩০ সেকেন্ডের বিরতি
  • Closed করে স্বাভাবিকভাবে সব ডাক পাঠানো
  • স্থায়ীভাবে open রাখা, হাতে না খোলা পর্যন্ত

Closed load-এ (প্রতিটি user আগের উত্তর পেয়ে তবেই পরের অনুরোধ পাঠান) প্রতি উত্তরে ১০০ ms দেরি যোগ করায় p95 সীমার মধ্যে রইল, কিন্তু ২০ সেকেন্ডে journey ৬৯১ থেকে ৫১১-তে নামল। সবচেয়ে সঠিক সিদ্ধান্ত কোনটি?

  • p95 সীমার মধ্যে, তাই system পুরোপুরি resilient
  • Server ক্র্যাশ করেছিল বলে journey কমেছে
  • Closed load ধীরতার কিছু প্রভাব লুকায়; hypothesis-এ throughput রাখা আর open load-এ যাচাই করা দরকার
  • Journey-র সংখ্যা ভুল মাপা হয়েছে, উপেক্ষা করা যায়

শব্দকোষ

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

মনে রাখুন

  1. Chaos experiment একটি test: আগে মাপা steady state, লেখা hypothesis, ছোট blast radius, abort condition, rollback আর control; রায় টিকল বা ভাঙল।
  2. Latency-র run: ১০০ ms-এ টিকল, ২৫০ ms-এ p95 ১১৪২ ms-এ ভাঙল; closed load-এ throughput-এর পতন লুকায়, তাই সেটিও hypothesis-এ রাখুন। Rollback-এর জন্য --rollback-strategy always.
  3. ধীর dependency সব থামাতে পারে: lock-এর ভেতরে wallet-এর ডাকে cash checkout ১৩.৬%-এ নামল; lock-এর বাইরে আনার পরে একই experiment-এ ১০০%. Fix-এর পরে regression suite আর একই experiment আবার।
  4. Correctness ছাড়া রায় অসম্পূর্ণ: হারানো উত্তরে ৩৪৯টি অপরিশোধিত order-এ টাকা কাটা; load-এর মাঝে kill-এ ০.৯ সেকেন্ডে ফেরা, ভুল charge শূন্য, তবে তিনটি order আটকে।
  5. সুরক্ষার কোডও test চায়: সঙ্গে সঙ্গে retry-তে চারগুণ ভার, backoff-এ দেরিতে শান্ত হওয়া; ব্যর্থ trial-এর পরে breaker-এর বিরতি নতুন করে শুরু না হওয়ার bug ধরল একটি unittest.

পরের পর্বে: মডিউল ১১ শুরু। পর্ব ৬৪ (CI-তে test pipeline — stage, parallel, gate আর দ্রুত feedback)-এ এ পর্যন্ত লেখা সব ধরনের test কোন ধাপে, কোন ক্রমে, কত সময়ে চলবে তা সাজাবেন; এই পর্বের মতো experiment-এর exit code কীভাবে একটি gate হয়, তাও দেখবেন।

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

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