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

Production-এ testing — canary, feature flag আর synthetic monitoring

Testing in Production — Canary, Feature Flags and Synthetic Monitoring

Taught in Bangla, this lesson shows shift-right testing as careful, measured checks with a fast way back. In a real local simulation with a sticky traffic-splitting proxy, a 10% canary's p95 jumps from 34 to 222 ms, the analysis script returns FAIL and routes all traffic back to stable. It explains why a 1% canary needs more time to prove an error rate, rolls a fix out through a feature flag with a kill switch, and shows a synthetic journey catching a wrong coupon total behind HTTP 200.

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

  • কেন আর কখন production-এ testing দরকার, আর কোন guardrail ছাড়া তা করা যায় না
  • Blue-green, rolling আর canary-তে tester কী যাচাই করেন, আর dark launch ও shadow traffic কোথায় কাজে আসে
  • Canary আর stable-এর error rate ও latency statistics দিয়ে তুলনা করে স্বয়ংক্রিয় rollback-এর রায় দেওয়া
  • Feature flag-এর percentage rollout, kill switch আর flag debt test করা
  • Synthetic monitoring, real user monitoring আর observability দিয়ে release-এর পরের সমস্যা ধরা

১ · কেন production-এ testing — shift-right আর তার সীমারেখা

নতুন রেসিপি বানিয়ে একজন রাঁধুনি রান্নাঘরে কয়েকবার চেখে দেখেন। তবু রেস্তোরাঁর মালিক প্রথম দিন পুরো মেনুতে নতুন পদটি দেন না। প্রথমে কয়েকটি টেবিলে দেন, খদ্দেরের মুখ আর ফেরত আসা প্লেট দেখেন, ভালো হলে বাকিদেরও দেন। রান্নাঘরের চাখা হলো release-এর আগের test; কয়েকটি টেবিলে দেওয়া হলো shift-right testing, অর্থাৎ release-এর পরেও পরিকল্পিত, ছোট আর নজরদারিসহ যাচাই। পর্ব ০৪-এ (SDLC আর STLC-তে testing) shift-left আর shift-right-এর ধারণা দেখেছেন; এই পর্ব shift-right-এর হাতে-কলমে রূপ।

এত test-এর পরেও production-এ কেন? কারণ কিছু জিনিস production-এর বাইরে নকল করা প্রায় অসম্ভব: আসল data-র আকার (পর্ব ৪৯-এ seed data-য় ১ ms-এর query চল্লিশ হাজার order-এ শত শত ms হয়েছিল), আসল ভিড়ের ঢেউ, হাজার রকম ফোন আর নেটওয়ার্ক, বাইরের সেবার আসল আচরণ, আর ব্যবহারকারীর আসল অভ্যাস। Staging যত কাছাকাছিই হোক, সে production-এর একটি মডেল। কোনো release শূন্য ঝুঁকির নয়, তাই আসল প্রশ্ন: production-এ প্রথম দেখা হলে কতজন আঘাত পাবেন, আর কত দ্রুত ধরা পড়বে।

এটি release-এর আগের test-এর বদলি নয়: unit থেকে E2E, contract, performance আর security gate সব আগের মতোই চলে, যার বিন্যাস পর্ব ৬৪-এর (CI-তে test pipeline) বিষয়। Shift-right সেই জাল পেরিয়ে যাওয়া সমস্যা ধরার শেষ স্তর। “Production-এ তো দেখবই” বলে আগের test কমানো হলো সবচেয়ে বিপজ্জনক ভুল বোঝা।

তাহলে নিরাপদে কীভাবে? চারটি প্রশ্নের উত্তর আগে থেকে লেখা থাকতে হয়। কতজন ঝুঁকিতে? ক্ষতির পরিধি বা blast radius ছোট রাখা: ১%, ৫% বা শুধু কর্মীরা। কীভাবে বুঝব খারাপ? আগে থেকে ঠিক করা মাপ আর সীমা, যেমন পর্ব ৫০-এর (SLO-ভিত্তিক test) SLO. কত দ্রুত ফিরব? একটি পরীক্ষিত rollback বা সুইচ, মিনিটে নয়, সেকেন্ডে। কোন side effect চলবে না? আসল টাকা কাটা, আসল SMS বা আসল ক্রেতার data নষ্ট হওয়া।

ঝুঁকিGuardrailবাজারঘরের উদাহরণ
অনেকে একসাথে আঘাত পানছোট ভাগে শুরু, ধাপে ধাপে বাড়ানোনতুন version প্রথমে ১০% ক্রেতার কাছে
সমস্যা দেরিতে চোখে পড়েআগে ঠিক করা মাপ আর স্বয়ংক্রিয় রায়p95 আর error rate-এর সীমা, analysis script
ফেরা ধীর বা অনিশ্চিতRollback আর kill switch, মহড়াসহProxy-র canary-র ভাগ ০, flag বন্ধ
Test-এর ক্ষতিকর side effectচিহ্নিত test account, নকল payment, রিপোর্ট থেকে বাদSynthetic check শুধু পড়ে, কিছু কেনে না
আসল ব্যক্তিগত তথ্য ফাঁসTest-এর ফলে ব্যক্তিগত data না রাখা, log-এ maskLog-এ visitor-এর নকল ID, ফোন নম্বর নয়

২ · Deployment কৌশল tester-এর চোখে — blue-green, rolling আর canary

নতুন version production-এ বসানোর কৌশলগুলোর পূর্ণ আলোচনা ক্লাউড ও DevOps কোর্সের পর্ব ৫৯-এ আর সিস্টেম ডিজাইন কোর্সের পর্ব ৫৩-এ আছে। এক লাইনে মনে করিয়ে দিই। Blue-green deployment-এ পুরোনো দলের পাশে নতুন পুরো দল চালু রেখে সব traffic এক ধাপে সরানো হয়। Rolling deployment-এ server একটি একটি করে বদলায়। Canary release-এ নতুন version প্রথমে ছোট এক ভাগ traffic পায়, মাপ ভালো হলে ভাগ বাড়ে। শেষেরটির সাধারণ নাম progressive delivery. Tester-এর প্রশ্ন হলো: প্রতিটিতে কী যাচাই করব, কখন?

কৌশলTester যা যাচাই করেনবিশেষ ঝুঁকি
Blue-greenSwitch-এর আগে green-এ smoke test আর synthetic journey; switch-এর পরে একই journey আবার; ফেরার switch-ও মহড়ায়Database দুই দলের মাঝে ভাগ করা; নতুন schema পুরোনো কোড ভাঙতে পারে
Rollingমাঝপথে পুরোনো আর নতুন একসাথে চলে: API আর data দুদিকে মেলে কি না (পর্ব ৩২-এর contract test)অর্ধেক server নতুন, অর্ধেক পুরোনো; ফেরার কাজও ধীর
CanaryCanary আর stable-এর মাপের তুলনা, স্বয়ংক্রিয় রায় আর rollback-এর পথছোট নমুনা, ভুল তুলনা, ধীর রায়

আরও দুটি কৌশল ব্যবহারকারীকে কিছু না দেখিয়েই production-এ নতুন কোড চালায়। Dark launch-এ নতুন অংশ আসল অনুরোধে চলে, কিন্তু ফল পর্দায় যায় না; উদাহরণ: বাজারঘরের নতুন search-এর ranking পাশাপাশি হিসাব হয়, log-এ লেখা হয়, ক্রেতা পুরোনো ফলই দেখেন। Shadow traffic-এ আসল অনুরোধের কপি নতুন version-এ পাঠানো হয় আর তার উত্তর ফেলে দেওয়া হয়। দুটিতেই tester-এর কাজ দুটি তুলনা: পুরোনো আর নতুন ফল কতটা মেলে, আর নতুন অংশের ভার ও latency. সাবধানতা একটাই, কিন্তু বড়: shadow-তে পাঠানো POST /api/orders/8/pay যদি সত্যিই টাকা কাটে, তাহলে “ছায়া” আর ছায়া থাকে না। তাই লেখার অনুরোধ shadow-তে যায় না, বা নকল gateway-তে যায়।

৩ · বাজারঘরের “production” — একটি স্থানীয় simulation

এই কোর্সের যন্ত্রে কোনো আসল production বা cloud নেই। তাই এই পর্বের “production” একটি স্থানীয় simulation, আর প্রতিটি সংখ্যা সেই simulation থেকে: বাজারঘরের app-এর (MIT) দুটি কপি নিজের scratch ফোল্ডারে, নিজের আলাদা SQLite ফাইলে, 127.0.0.1-এ। পুরোনো ভালো version, “stable 1.1”, চলে port 8853-এ; নতুন version, “canary 1.2”, port 8863-এ। সামনে Python-এর standard library দিয়ে লেখা একটি ছোট reverse proxy, port 8873-এ, যা প্রতিটি visitor-কে তার ID-র hash দেখে একটি দিকে পাঠায়: একে traffic splitting বলে। App চলেছে Python 3.12.13 আর Uvicorn 0.54.0-এ; কোনো বাইরের সেবা নেই, কোনো telemetry বাইরে যায়নি।

স্থানীয় “production”: proxy, দুই version, analysis আর rollback-এর পথ

Local simulation on 127.0.0.1 — sticky 10% split, log, verdict, weight back to 0

Shoppers and a synthetic monitor go through a proxy that sends 90% to stable and 10% to canary; the proxy log feeds canary analysis, which sets the canary share to 0 on failure শপার · ২০ জন load.py synthetic check synthetic.py proxy · 127.0.0.1:8873 visitor-এর hash → sticky ভাগ stable 1.1 :8853 · own DB canary 1.2 :8863 · own DB canary_analysis.py z-test + p95 → রায় ৯০% ১০% rollback: canary 0% log
ছবি ৬৬.১ — একই visitor সবসময় একই দিকে যান, অর্থাৎ ভাগটি sticky বা স্থির। Proxy প্রতিটি request-এর backend, status আর সময় এক লাইনের JSON-এ লেখে; analysis সেই log পড়ে রায় দেয়, আর FAIL হলে proxy-র canary-র ভাগ ০ করে।

Proxy-র মূল লাইন কয়েকটি। এটি X-Visitor-Id header-এর একটি hash নেয়, ১০০ দিয়ে ভাগশেষকে bucket ধরে, আর bucket canary-র শতাংশের কম হলে request canary-তে পাঠায়। Hash-ভিত্তিক এই ভাগকে sticky assignment বলে: একজন ক্রেতা search-এ নতুন version, কার্টে পুরোনো version, এমন খিচুড়ি অভিজ্ঞতা পান না। প্রতিটি request-এর পরে proxy এক লাইনের structured log লেখে, আর PUT /_proxy/weight দিয়ে চলমান অবস্থায় canary-র ভাগ বদলানো যায়।

visitor = self.headers.get("X-Visitor-Id", "")
name = "canary" if fnv1a(visitor) % 100 < STATE["canary_percent"] else "stable"
# ... forward to 127.0.0.1:8853 or :8863, measure the time ...
LOG.write(json.dumps({"t": ..., "backend": name, "visitor": visitor,
                      "path": path, "status": status, "ms": round(ms, 1)}) + "\n")

ভার দেয় load.py: ২০টি thread, প্রতিটি একজন করে নতুন ক্রেতার journey চালায়, যেমন search (“oil”, “চাল”, “তেল”…), একটি পণ্যের পাতা, আর একটি দামের quote; প্রতিটি কাজের পরে ০.১–০.৩ সেকেন্ড বিরতি। প্রতিটি run ৬০ সেকেন্ডের, যাতে যন্ত্রের ওপর চাপ সীমিত থাকে। প্রথমে একটি ভালো canary দিয়ে মহড়া, যেখানে দুটি কপিতে একই কোড; analysis-এর কাজ এখানে চুপ থাকা। সত্যিকারের run:

$ python run_canary.py good          # canary = same code as stable
stable  requests= 4857 errors=  0 (0.00%)  p50=   8.0 ms  p95=  31.5 ms
canary  requests=  543 errors=  0 (0.00%)  p50=   4.1 ms  p95=  27.0 ms
error rate: z=0.00  p=0.500
VERDICT PASS
exit code: 0
[phase 2: 15 s after the decision] {'canary': 147, 'stable': 1215}

দুটি জিনিস দেখার। প্রথমত, ভাগটি ঠিক আছে: ৫,৪০০টি request-এর ৫৪৩টি, অর্থাৎ ১০.১%, canary-তে গেছে। এটি নিজেই একটি test: ভাগ পরিকল্পনা থেকে অনেক সরে গেলে (A/B test-এর জগতে যাকে sample ratio mismatch বলে) routing বা log-এ ভুল আছে, আর বাকি তুলনা অর্থহীন। দ্বিতীয়ত, কোড এক হলেও দুই দলের সংখ্যা এক নয়: stable-এর p95 ৩১.৫, canary-র ২৭.০ ms. এটি noise; canary-তে ভিড় কম বলে সামান্য দ্রুত। তাই রায়ের নিয়মে শুধু “খারাপ হলো কি না” নয়, “noise-এর সীমা ছাড়িয়ে খারাপ হলো কি না” লাগে। PASS-এর পরে canary ১০%-এই রইল (দ্বিতীয় ধাপে ১,৩৬২টির ১৪৭টি)।

৪ · Canary analysis — সংখ্যা দিয়ে রায় আর স্বয়ংক্রিয় rollback

এবার canary-তে একটি সত্যিকারের ত্রুটি: বাজারঘরের বসানো ভুল slow_search চালু, BAZARGHAR_SLOW_MS=200 দিয়ে ২০০ ms দেরিতে। এটি এমন একটি ভুল, যা কোনো functional test ধরে না: সব উত্তর সঠিক, সব status 200. Canary analysis-এর নিয়ম তিনটি, আর প্রতিটি আগে থেকে লেখা: (১) canary-তে অন্তত ২০০টি request না হলে রায় নেই; (২) error rate-এ two-proportion z-test, একদিকে, p < ০.০১ এবং পার্থক্য ০.৫ শতাংশ-বিন্দুর বেশি হলে FAIL; (৩) canary-র p95 stable-এর ১.২৫ গুণের বেশি এবং ২৫ ms-এর বেশি হলে FAIL. দুই শর্তের এই জোড়া পর্ব ৫০-এর CI gate-এর মতোই noise সামলায়।

pool = (e_s + e_c) / (n_s + n_c)                 # two-proportion z-test, one-sided
se = math.sqrt(pool * (1 - pool) * (1 / n_s + 1 / n_c)) or float("inf")
z = (e_c / n_c - e_s / n_s) / se
p = 0.5 * math.erfc(z / math.sqrt(2))

fails = []
if n_c < 200: fails.append(f"too few canary requests ({n_c})")
if p < 0.01 and e_c / n_c - e_s / n_s > 0.005: fails.append("error rate higher")
if p95_c > 1.25 * p95_s and p95_c - p95_s > 25: fails.append(f"p95 {p95_s:.0f} -> {p95_c:.0f} ms")
print("VERDICT", "FAIL: " + "; ".join(fails) if fails else "PASS")
if fails:                                        # automatic rollback: canary weight -> 0
    req = urllib.request.Request("http://127.0.0.1:8873/_proxy/weight", method="PUT",
                                 data=b'{"canary_percent": 0}')
    print("ROLLBACK", urllib.request.urlopen(req).read().decode())
sys.exit(1 if fails else 0)

সত্যিকারের run, একই ভার, একই ৬০ সেকেন্ড:

$ python run_canary.py bad           # canary 1.2 = slow_search, 200 ms
stable  requests= 4665 errors=  0 (0.00%)  p50=   7.5 ms  p95=  33.5 ms
canary  requests=  525 errors=  0 (0.00%)  p50=  18.6 ms  p95= 222.5 ms
error rate: z=0.00  p=0.500
VERDICT FAIL: p95 34 -> 222 ms
ROLLBACK {"canary_percent": 0}
exit code: 1
[phase 2: 15 s after the decision] {'stable': 1353}

Error rate দুদিকেই শূন্য, তাই শুধু error দেখলে canary পাস করত। Latency-র নিয়ম ধরল: p95 ৩৪ থেকে ২২২ ms. Endpoint ধরে ভাঙলে কারণ স্পষ্ট: canary-র search (/api/products) p50 ২০৫ আর p95 ২৩০ ms, যেখানে stable-এর ১১.৬ আর ৩৭.৫; কিন্তু দামের quote-এ দুদিকে প্রায় সমান (p95 ২৮.৩ বনাম ২৯.৯)। Rollback-এর পরের ১৫ সেকেন্ডে ১,৩৫৩টি request-এর একটিও canary-তে যায়নি। নিচের stepper-এ পুরো যাত্রাটি ধাপে ধাপে দেখুন।

  1. Deploy1.2 → :8863শূন্য traffic
  2. ১০%sticky hash৬০ s ভার
  3. মাপproxy logদুই দল
  4. রায়FAILp95 নিয়ম
  5. Rollbackcanary 0%যাচাইসহ
দুটি versionআলাদা DB
stable 1.1 → 127.0.0.1:8853  bugs: none
canary 1.2 → 127.0.0.1:8863  bugs: slow_search
proxy      → 127.0.0.1:8873  canary_percent = 10
# deploy হলো, release এখনো হয়নি
ভাগ৫,১৯০ request
stable : 4665  (89.9%)
canary :  525  (10.1%)
# পরিকল্পনা ১০%: ভাগ ঠিক আছে
মাপerror · p50 · p95
stable  0/4665  7.5 ms   33.5 ms
canary  0/525  18.6 ms  222.5 ms
# search: 230 ms বনাম 37.5 ms
নিয়মআগে লেখা
n_canary 525 ≥ 200        ✓ রায় দেওয়া যায়
error: z=0.00 p=0.500     ✓ পার্থক্য নেই
p95: 222 > 1.25×34 আর +188 > 25
VERDICT FAIL → exit 1
PUT /_proxy/weightপরের ১৫ s
{"canary_percent": 0}
stable : 1353
canary :    0
# rollback নিজেও যাচাই করা হলো
  1. Deploy, release নয়। নতুন version নিজের port আর নিজের database-এ চালু, কিন্তু এখনো কোনো ক্রেতা সেখানে যান না। Deploy মানে কোড বসানো; release মানে মানুষের কাছে খোলা। দুটি আলাদা করাই progressive delivery-র মূল কথা।
  2. ১০% ভাগ। Proxy visitor-এর hash দেখে ভাগ করে। ৬০ সেকেন্ডে ৫,১৯০টি request-এর ৫২৫টি, অর্থাৎ ১০.১%, canary-তে গেল। পরিকল্পনার সাথে ভাগ মেলানো প্রথম যাচাই।
  3. মাপ। একই সময়ে, একই ধরনের ক্রেতার ওপর দুই দলের মাপ: error দুদিকেই শূন্য, কিন্তু canary-র p95 ২২২.৫ ms, stable-এর ৩৩.৫. একই সময়ের তুলনা জরুরি; গতকালের stable-এর সাথে তুলনা করলে দিনের ভিড়ের পার্থক্যও মিশে যেত।
  4. রায়। নমুনা যথেষ্ট (৫২৫ ≥ ২০০); error-এর z-test-এ কোনো পার্থক্য নেই; কিন্তু p95-এর দুটি শর্তই ভাঙল: ২২২ > ১.২৫ × ৩৪ আর বৃদ্ধি ১৮৮ ms > ২৫. রায় FAIL, exit code 1.
  5. Rollback আর তার যাচাই। Script নিজেই proxy-র canary-র ভাগ ০ করল। তারপর ১৫ সেকেন্ডের ভারে ১,৩৫৩টি request-এর সবই stable-এ: rollback “হয়েছে” বলে ধরে নেওয়া হয়নি, মেপে দেখা হয়েছে।

কত বড় canary, কত সময়? — statistics

Latency-র পার্থক্য এখানে বিশাল ছিল। কিন্তু ধরুন নতুন version-এ error rate ০.৫% থেকে ১.৫% হয়েছে: ১০০০ জনে ১০ জন বেশি ক্রেতা checkout-এ ব্যর্থ। নিচের ব্লক একটি কাল্পনিক, seed দেওয়া simulation-এ একই খারাপ canary দুইভাবে চালায়: ১০% traffic আর ১% traffic, মোট ১০,০০০ request. প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import math, random
random.seed(66)

def release(n, err_rate, extra_ms):
    """n invented requests: error count, p50 and p95 latency."""
    errors = sum(random.random() < err_rate for _ in range(n))
    ms = sorted(random.lognormvariate(math.log(40), 0.5) + extra_ms for _ in range(n))
    return n, errors, ms[n // 2], ms[int(0.95 * n)]

def z_test(n1, e1, n2, e2):
    """Two-proportion z-test, one-sided: is group 2's error rate higher?"""
    pool = (e1 + e2) / (n1 + n2)
    se = math.sqrt(pool * (1 - pool) * (1 / n1 + 1 / n2))
    z = (e2 / n2 - e1 / n1) / se
    return z, 0.5 * math.erfc(z / math.sqrt(2))

for share in (0.10, 0.01):                  # canary gets 10% or 1% of 10,000
    n_c = round(10_000 * share)
    stable = release(10_000 - n_c, 0.005, 0)      # 0.5% errors
    canary = release(n_c, 0.015, 12)              # 1.5% errors, +12 ms
    print(f"canary share {share:.0%}")
    for name, (n, e, p50, p95) in (("stable", stable), ("canary", canary)):
        print(f"  {name}: n={n:5} errors={e:3} ({e / n:.2%})"
              f"  p50={p50:5.1f}  p95={p95:5.1f} ms")
    z, p = z_test(stable[0], stable[1], canary[0], canary[1])
    verdict = "FAIL -> rollback" if p < 0.01 else "not enough evidence"
    print(f"  z={z:.2f}  p={p:.4f}  {verdict}")

আসল আউটপুট:

canary share 10%
  stable: n= 9000 errors= 35 (0.39%)  p50= 40.3  p95= 90.8 ms
  canary: n= 1000 errors= 18 (1.80%)  p50= 52.7  p95=107.6 ms
  z=5.83  p=0.0000  FAIL -> rollback
canary share 1%
  stable: n= 9900 errors= 64 (0.65%)  p50= 39.9  p95= 90.3 ms
  canary: n=  100 errors=  1 (1.00%)  p50= 52.7  p95=100.7 ms
  z=0.44  p=0.3308  not enough evidence

একই খারাপ version, একই সত্যিকারের error-এর হার। ১০% ভাগে canary-র ১,০০০টি request-এ ১৮টি error, z = ৫.৮৩, p প্রায় শূন্য: রায় স্পষ্ট। ১% ভাগে মাত্র ১০০টি request-এ ১টি error; ১.৫% হারে গড়ে দেড়টি আশা করা যায়, তাই এই সংখ্যা stable-এর ০.৬৫%-এর থেকে আলাদা করা যায় না (p = ০.৩৩)। “Canary পাস করেছে” কথাটি এখানে ভুল; সঠিক কথা “প্রমাণ যথেষ্ট নয়”. দুই run-এ stable-এর হারও আলাদা (০.৩৯% আর ০.৬৫%), যদিও আসল হার একই ০.৫%: এলোমেলো ওঠানামা। random.seed(66) বদলে চালিয়ে দেখুন, ১% ভাগের রায় কতটা নড়ে।

তাহলে ছোট canary কতক্ষণ চালাতে হবে? এটি statistical power-এর প্রশ্ন: আসল পার্থক্য থাকলে test তা কত সম্ভাবনায় ধরবে। নিচের ব্লক প্রচলিত সূত্রে হিসাব করে, প্রতিটি দলে কত request লাগবে (α = ০.০১, power ৮০%), আর মিনিটে ৬০০ request-এর একটি কাল্পনিক দোকানে তা কত মিনিট।

from math import ceil, sqrt
from statistics import NormalDist

Z = NormalDist().inv_cdf

def per_group(p_base, p_bad, alpha=0.01, power=0.80):
    """Requests needed in EACH group to notice p_base -> p_bad (one-sided)."""
    p_bar = (p_base + p_bad) / 2
    a = Z(1 - alpha) * sqrt(2 * p_bar * (1 - p_bar))
    b = Z(power) * sqrt(p_base * (1 - p_base) + p_bad * (1 - p_bad))
    return ceil(((a + b) / (p_bad - p_base)) ** 2)

TRAFFIC = 600                     # invented: requests per minute on the shop
print("base -> bad       n/group  min @10%  min @1%")
for p_base, p_bad in ((0.005, 0.015), (0.005, 0.010), (0.005, 0.0075)):
    n = per_group(p_base, p_bad)
    m10, m1 = n / (TRAFFIC * 0.10), n / (TRAFFIC * 0.01)
    print(f"{p_base:.2%} -> {p_bad:.2%} {n:8,} {m10:9.0f} {m1:8.0f}")

আসল আউটপুট:

base -> bad       n/group  min @10%  min @1%
0.50% -> 1.50%    1,986        33      331
0.50% -> 1.00%    5,976       100      996
0.50% -> 0.75%   19,946       332     3324

প্রথম সারি আগের ব্লকের ঘটনা: ০.৫% থেকে ১.৫% ধরতে canary-তে প্রায় ২,০০০ request লাগে; ১০% ভাগে ৩৩ মিনিট, ১% ভাগে ৩৩১ মিনিট, সাড়ে পাঁচ ঘণ্টার বেশি। পার্থক্য অর্ধেক হলে (১.০%) দরকারি নমুনা তিন গুণ, আর আরও ছোট পার্থক্যে (০.৭৫%) দশ গুণ। এখান থেকে তিনটি ব্যবহারিক নিয়ম: (১) canary-র ভাগ আর সময় একসাথে ঠিক করুন, আগে থেকে; (২) রায়ের আগে বারবার ফল দেখে প্রথম “লাল” মুহূর্তে থামানো (peeking) মিথ্যা alarm বাড়ায়, যা মেশিন লার্নিং কোর্সের পর্ব ৬২-এ বিস্তারিত; (৩) খুব বড় ক্ষতির জন্য (সব error, সব ধীর) আলাদা দ্রুত নিয়ম রাখুন, যা কয়েকশ request-এই রায় দেয়।

৫ · Feature flag — kill switch, ধাপে ধাপে rollout আর flag debt

বাড়ির মেইন সুইচ আর ঘরের আলাদা সুইচের কথা ভাবুন। পুরো বাড়ির তার নতুন করে বসানো (deploy) একটি বড় কাজ; কিন্তু তার বসানো হয়ে গেলে কোন ঘরের বাতি কখন জ্বলবে, তা সুইচ দিয়ে ঠিক হয়। Feature flag একই কাজ করে: নতুন কোড production-এ থাকে, কিন্তু কার জন্য চালু, তা একটি সেটিং ঠিক করে, নতুন deploy ছাড়াই। Flag-এর ধরন ও নকশা ক্লাউড ও DevOps কোর্সের পর্ব ৫৯-এ আছে; এখানে প্রশ্ন, flag-কে কীভাবে test করবেন।

উদাহরণটি এই কোর্সেরই একটি পুরোনো defect. পর্ব ৫৬-এ (Localization testing) দেখেছেন, “য়” অক্ষরটি একটি code point (U+09DF) হিসেবে টাইপ করলে বাজারঘরের search “সয়াবিন তেল” খুঁজে পায় না, কারণ search Unicode-কে normalise করে না। সংশোধন সহজ: খোঁজার শব্দকে NFC রূপে আনা। কিন্তু search সবার ব্যবহারের পথ; সংশোধনে নতুন কোনো ভুল থাকলে সবাই আঘাত পাবেন। তাই এই পর্বের কপিতে সংশোধনটি একটি flag-এর পেছনে বসানো হলো: search_nfc. Flag-এর সেটিং থাকে একটি JSON ফাইলে, যা প্রতিটি request-এ আবার পড়া হয়; ফাইল পড়া না গেলে flag বন্ধ, অর্থাৎ নিরাপদ ডিফল্ট। চালু থাকলে percentage rollout: visitor-এর ID-র hash থেকে ০–৯৯-এর একটি bucket, আর bucket শতাংশের কম হলে নতুন পথ।

def bucket(flag: str, visitor: str) -> int:
    return fnv1a(f"{flag}:{visitor}") % 100          # 0..99, sticky per visitor

def enabled(flag: str, visitor: str) -> bool:
    path = os.environ.get("BAZARGHAR_FLAGS", "")
    try:
        cfg = json.load(open(path, encoding="utf-8")).get(flag, {}) if path else {}
    except (OSError, ValueError):
        cfg = {}                                      # unreadable file = flag off (safe default)
    return bool(cfg.get("on")) and bucket(flag, visitor) < int(cfg.get("percent", 0))

flag_demo.py stable কপিটি একবার চালু করে, তারপর server না থামিয়ে flag-এর ফাইল পাঁচবার বদলায়। প্রতিবার ২০ জন visitor (v01…v20) একটি code point-এর “য়” দিয়ে “সয়াবিন” খোঁজেন, আর regression-এর পাহারা হিসেবে “oil”-ও খোঁজেন (ঠিক উত্তর ২টি পণ্য)। সত্যিকারের run:

$ python flag_demo.py
no flag      found 'সয়াবিন':  0/20  'oil' ok: 20/20  earlier kept: -  []
on, 10%      found 'সয়াবিন':  2/20  'oil' ok: 20/20  earlier kept: -  ['v07', 'v10']
on, 50%      found 'সয়াবিন': 10/20  'oil' ok: 20/20  earlier kept: yes  ['v02', 'v03']
on, 100%     found 'সয়াবিন': 20/20  'oil' ok: 20/20  earlier kept: yes  ['v01', 'v02']
kill switch  found 'সয়াবিন':  0/20  'oil' ok: 20/20  earlier kept: -  []
server pid unchanged: True
1{}2{"search_nfc": {"on": true, "percent": 10}}3{"search_nfc": {"on": true, "percent": 50}}4{"search_nfc": {"on": true, "percent": 100}}5{"search_nfc": {"on": false, "percent": 100}}6# flag আর পুরোনো শাখা কোড থেকে মুছে ফেলা
২০ জন visitor
সয়াবিন পেলেন
oil ঠিক
restart
  1. কোড আছে, flag নেই। সংশোধনের কোড production-এ deploy হয়েছে, কিন্তু flag-এর সেটিং নেই, তাই নিরাপদ ডিফল্টে বন্ধ। ২০ জনের কেউ “সয়াবিন” পান না, আগের মতো; “oil” সবার জন্য ঠিক।
  2. ১০%. ২০ জনের মধ্যে ২ জন, v07 আর v10, নতুন পথে গেলেন আর পণ্যটি পেলেন। ২০ জনের ছোট দলে ১০% মানে ঠিক ২ জন হবেই, এমন নয়; এখানে কাকতালীয়ভাবে মিলেছে।
  3. ৫০%. ১০ জন পেলেন, আর আগের দুজন তাঁদের মধ্যেই আছেন; earlier kept: yes লাইনটি তা-ই বলে। শতাংশ বাড়ালে আগে পাওয়া কেউ হারান না, কারণ প্রত্যেকের bucket স্থির।
  4. ১০০%. সবাই পেলেন, “oil” তখনও ২০/২০। এখন সংশোধনটি পুরোপুরি release হলো, অথচ পুরো সময়ে server একবারও থামেনি; শেষ লাইনের server pid unchanged: True তার প্রমাণ।
  5. Kill switch. ধরুন নতুন পথে কোনো সমস্যা ধরা পড়ল। "on": false লিখতেই পরের request থেকে সবাই পুরোনো পথে; কোনো rollback, build বা deploy লাগল না।
  6. পরিষ্কার করা। সংশোধন স্থায়ী হলে flag-এর পরীক্ষা আর পুরোনো শাখা কোড থেকে মুছে একটি সাধারণ deploy; তখন NFC সবসময়। এটি না করলে পুরোনো flag জমে flag debt হয়।

Bucket-এর নিয়মটি এবার নিজে চালিয়ে দেখুন। নিচের JavaScript ব্লকে একই FNV-1a hash আর একই নিয়ম; এটি lab-এর Python কোডের সাথে মেলে কি না, সেটিও একটি test.

// FNV-1a 32-bit hash -> bucket 0..99 (same rule as the lab's flags.py)
function fnv1a(text) {
  let h = 0x811c9dc5;
  for (const b of new TextEncoder().encode(text)) {
    h = Math.imul(h ^ b, 0x01000193) >>> 0;
  }
  return h;
}
const bucket = (flag, visitor) => fnv1a(flag + ":" + visitor) % 100;
const isOn = (flag, visitor, cfg) => cfg.on && bucket(flag, visitor) < cfg.percent;

const visitors = Array.from({ length: 20 }, (_, i) => "v" + String(i + 1).padStart(2, "0"));
for (const percent of [10, 50, 100]) {
  const on = visitors.filter(v => isOn("search_nfc", v, { on: true, percent }));
  console.log(`${percent}%: ${on.length}/20 -> ${on.slice(0, 6).join(" ")}${on.length > 6 ? " ..." : ""}`);
}

// 10,000 invented visitor ids: is the real share close to the setting?
const many = Array.from({ length: 10000 }, (_, i) => "user-" + i);
for (const percent of [1, 10, 50]) {
  const n = many.filter(v => isOn("search_nfc", v, { on: true, percent })).length;
  console.log(`setting ${percent}% -> ${(n / 100).toFixed(2)}% of 10,000`);
}

// Two flags at 10%: is it the SAME 10% of people?
const both = many.filter(v => isOn("search_nfc", v, { on: true, percent: 10 }) &&
                              isOn("new_checkout", v, { on: true, percent: 10 })).length;
console.log(`in both 10% groups: ${both} people (independent would be about 100)`);

আসল আউটপুট:

10%: 2/20 -> v07 v10
50%: 10/20 -> v02 v03 v06 v07 v09 v10 ...
100%: 20/20 -> v01 v02 v03 v04 v05 v06 ...
setting 1% -> 1.06% of 10,000
setting 10% -> 10.00% of 10,000
setting 50% -> 50.12% of 10,000
in both 10% groups: 56 people (independent would be about 100)

প্রথম তিন লাইন lab-এর সত্যিকারের run-এর সাথে হুবহু মেলে: ১০%-এ v07 আর v10. দুই ভাষার implementation একই উত্তর দিল, আর ১০,০০০ ID-তে বাস্তব ভাগ সেটিং-এর খুব কাছে। কিন্তু শেষ লাইনটি একটি সত্যিকারের আবিষ্কার: দুটি আলাদা flag ১০%-এ থাকলে স্বাধীন ভাগে প্রায় ১০০ জন দুটিতেই পড়ার কথা (১০% × ১০% × ১০,০০০), এখানে মাত্র ৫৬. অর্থাৎ এই সরল hash-এ দুই flag-এর দল পরস্পর থেকে স্বাধীন নয়। Kill switch-এ এটি তুচ্ছ, কিন্তু একসাথে দুটি A/B experiment চালালে একটির ফল অন্যটিতে মিশতে পারে। শিক্ষা: ভাগের নিয়মকেও test করুন, আর প্রয়োজনে আরও শক্ত hash নিন।

Flag-এর নিয়মগুলো লিখিত হলে সেগুলো সাধারণ unit test হয়ে যায়। নিচের ব্লকে একই চারটি test দুটি implementation-এর ওপর চলে: hash-ভিত্তিক sticky আর প্রতিটি request-এ নতুন করে মুদ্রা ছোড়ার মতো per_request, যা অনেক AI সহকারী আর তাড়াহুড়োর কোড প্রথমে লেখে।

import random, sys, unittest

def fnv1a(text):
    h = 0x811C9DC5
    for b in text.encode():
        h = ((h ^ b) * 0x01000193) & 0xFFFFFFFF
    return h

def sticky(visitor, cfg):          # bucket from a hash of flag + visitor
    return cfg["on"] and fnv1a("search_nfc:" + visitor) % 100 < cfg["percent"]

rng = random.Random(7)
def per_request(visitor, cfg):     # a new coin toss on every request
    return cfg["on"] and rng.random() * 100 < cfg["percent"]

IDS = [f"user-{i}" for i in range(2000)]
class FlagRules:
    def ev(self, v, pct, on=True):
        return type(self).impl(v, {"on": on, "percent": pct})
    def test_kill_switch_turns_everyone_off(self):
        self.assertFalse(any(self.ev(v, 100, on=False) for v in IDS))
    def test_share_close_to_setting(self):
        share = sum(self.ev(v, 10) for v in IDS) / len(IDS)
        self.assertAlmostEqual(share, 0.10, delta=0.02)
    def test_same_visitor_same_answer(self):
        self.assertTrue(all(self.ev(v, 50) == self.ev(v, 50) for v in IDS))
    def test_raising_percent_keeps_earlier_people(self):
        self.assertTrue(all(self.ev(v, 50) for v in IDS if self.ev(v, 10)))

class Sticky(FlagRules, unittest.TestCase): impl = staticmethod(sticky)
class PerRequest(FlagRules, unittest.TestCase): impl = staticmethod(per_request)

suite = unittest.TestSuite(unittest.defaultTestLoader.loadTestsFromTestCase(c)
                           for c in (Sticky, PerRequest))
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)

আসল আউটপুট (সংক্ষেপে; traceback-এর মাঝের লাইন বাদ):

test_kill_switch_turns_everyone_off (__main__.Sticky.test_kill_switch_turns_everyone_off) ... ok
test_raising_percent_keeps_earlier_people (__main__.Sticky.test_raising_percent_keeps_earlier_people) ... ok
test_same_visitor_same_answer (__main__.Sticky.test_same_visitor_same_answer) ... ok
test_share_close_to_setting (__main__.Sticky.test_share_close_to_setting) ... ok
test_kill_switch_turns_everyone_off (__main__.PerRequest.test_kill_switch_turns_everyone_off) ... ok
test_raising_percent_keeps_earlier_people (__main__.PerRequest.test_raising_percent_keeps_earlier_people) ... FAIL
test_same_visitor_same_answer (__main__.PerRequest.test_same_visitor_same_answer) ... FAIL
test_share_close_to_setting (__main__.PerRequest.test_share_close_to_setting) ... ok

======================================================================
FAIL: test_raising_percent_keeps_earlier_people (__main__.PerRequest.test_raising_percent_keeps_earlier_people)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 28, in test_raising_percent_keeps_earlier_people
…
AssertionError: False is not true
…
FAILED (failures=2)

দুটি implementation-ই প্রথম নজরে ঠিক: kill switch দুটিতেই সবাইকে বন্ধ করে, আর দুটিতেই প্রায় ১০% মানুষ flag পান। একটি সাধারণ “share ১০% কি না” test দুটিকেই পাস করাত। কিন্তু per_request দুটি গুরুত্বপূর্ণ নিয়ম ভাঙে, আর test দুটি সত্যিই FAIL হলো: একই visitor পরপর দুবার ভিন্ন উত্তর পান (একবার নতুন search, একবার পুরোনো), আর ১০% থেকে ৫০%-এ বাড়ালে আগে পাওয়া কেউ কেউ হারান। Production-এ এর মানে, ক্রেতার পর্দায় feature আসে-যায়, আর canary-র মাপে দুই দলের মানুষ মিশে যায়। শিক্ষা: flag-এর test-এ শুধু “শতাংশ ঠিক কি না” নয়, স্থিরতা আর একমুখী বৃদ্ধিও লিখুন।

Flag debt আর test-এর সমন্বয়: প্রতিটি flag কোডের পথ দ্বিগুণ করে; দশটি স্বাধীন flag মানে তত্ত্বে ১,০২৪টি সমন্বয়। তাই প্রচলিত নিয়ম: CI-তে অন্তত দুটি অবস্থা, “production-এ এখন যা” আর “পরের release-এ যা হবে”, আর প্রতিটি flag-এর একজন মালিক ও মেয়াদ। পরস্পরের ওপর নির্ভরশীল flag-এর জোড়া পর্ব ১১-এর (Pairwise testing) কৌশলে বাছাই করা যায়। ব্যবহৃত flag-এর পরিষেবা নিজেরা না বানালে খোলা উৎসের বিকল্পও আছে: OpenFeature (CNCF-এর একটি প্রকল্প, flag-এর একটি সাধারণ API, Apache-2.0), Unleash (Apache-2.0) আর Flagsmith (BSD-3-Clause) তার কয়েকটি।

৬ · A/B test বনাম canary, আর আসল data-য় নিরাপদে test

A/B test আর canary দুটিতেই ব্যবহারকারী দুই দলে ভাগ হন, আর দুই দলের মাপ তুলনা হয়। তাই দুটিকে প্রায়ই এক ভাবা হয়, কিন্তু প্রশ্ন আলাদা। Canary জিজ্ঞেস করে: “নতুন version কি কিছু ভাঙল?” এর মাপ প্রযুক্তিগত (error, latency, crash), সময় মিনিট থেকে ঘণ্টা, আর সন্দেহ হলে দ্রুত ফেরা। A/B test জিজ্ঞেস করে: “কোন রূপ ব্যবসার জন্য ভালো?” এর মাপ আচরণের (অর্ডার সম্পূর্ণ হওয়ার হার, কার্টের আকার), সময় দিন থেকে সপ্তাহ, যাতে সপ্তাহের দিনের পার্থক্যও ধরা পড়ে। পর্ব ৫৫-এ (Usability testing) দেখেছেন, A/B test বলে কোনটি জিতল, কিন্তু কেন, তা বলে না।

Tester-এর কাজ দুটিতে এক জায়গায় মেলে: পরীক্ষার যন্ত্রটি নিজে ঠিক আছে কি না. ভাগ পরিকল্পনামতো কি না (আগের ১০.১%-এর যাচাই), একই ব্যবহারকারী একই দলে থাকেন কি না, দুই দলের event একইভাবে log হয় কি না, আর guardrail metric (যেমন checkout-এর error) খারাপ হলো কি না। অনেক দল experiment-এর আগে একই রূপ দুই দলে দিয়ে (A/A test) দেখে, পার্থক্য আসে কি না; এলে যন্ত্রে ভুল। Experiment-এর statistics মেশিন লার্নিং কোর্সের পর্ব ৬২ আর পর্ব ৬৩-এ আছে।

আসল data-র মাঝে test — test account আর side effect

Production-এ কিছু test-কে লিখতেই হয়: একটি order দেওয়া, payment-এর পথ যাচাই। সেখানে নিয়মগুলো কড়া। প্রথমত, চিহ্নিত test account: যেমন synthetic-01@bazarghar.test, যার order আর payment প্রতিটি রিপোর্ট, হিসাব আর recommendation থেকে বাদ যায়, আর গুদামে মাল বরাদ্দ করে না। দ্বিতীয়ত, নকল টাকার পথ: test account-এর payment সবসময় বাজারঘরের FAKE gateway বা পেমেন্ট সেবার test mode-এ যায়; আসল টাকা কাটার পথ test-এর কোড থেকে কখনো খোলা যায় না। তৃতীয়ত, পরিষ্কার করা: test-এর order দ্রুত বাতিল হয়, আর data জমে না। চতুর্থত, আসল ব্যক্তিগত তথ্য না দেখা: production-এর log বা data থেকে কোনো ক্রেতার নাম, ফোন বা ঠিকানা test রিপোর্টে আসে না; production-এর data-র masked কপি কীভাবে বানাতে হয়, তা পর্ব ৬৫-এ (Test environment আর test data) দেখেছেন। এই নিয়মগুলো লেখা না থাকলে production-এ test করা অনুমতি পায় না, আর পাওয়াও উচিত নয়।

৭ · Synthetic monitoring আর real user monitoring

বাসের কাউন্টারের ম্যানেজার দুইভাবে জানতে পারেন বাস ঠিকমতো চলছে কি না। এক, প্রতি ঘণ্টায় একজন কর্মীকে টিকিট কেটে একটি ছোট পথ ঘুরে আসতে বলা; দুই, যাত্রীদের অভিযোগের খাতা দেখা। প্রথমটি synthetic monitoring: একটি script নিয়মিত ব্যবহারকারীর মতো একটি journey চালায়, আর প্রতিটি ধাপের ফল মেলায়। দ্বিতীয়টি real user monitoring (RUM): আসল ব্যবহারকারীর browser থেকে পাতার সময় আর error সংগ্রহ। Synthetic রাত তিনটায়ও কাজ করে, যখন কোনো ক্রেতা নেই, আর ফল তুলনাযোগ্য কারণ journey একই; কিন্তু সে শুধু লেখা পথগুলোই দেখে। RUM সব যন্ত্র আর সব পথ দেখে, কিন্তু সমস্যা ধরা পড়ে কেউ আঘাত পাওয়ার পরে।

Tester-এর জন্য synthetic check হলো production-এ চলমান একটি smoke test, আর তার শক্তি assertion-এ। শুধু “HTTP 200 এল কি না” দেখলে সেটি একটি health check; journey-র প্রতিটি সংখ্যা ব্যবসার নিয়মের সাথে মেলালে সেটি সত্যিকারের test. বাজারঘরের check-এ চারটি ধাপ, আর coupon-এর নিয়ম (১০০০ টাকার বেশিতে ১০% ছাড়) পর্ব ০৮-এর (Boundary value analysis) boundary-র মান দিয়ে যাচাই করা: ১০০০-এ ছাড় ০, ১০০১-এ ১০০.

STEPS = [  # (name, path, check on the JSON body)
    ("health", "/api/health", lambda b: b["status"] == "ok"),
    ("search oil", "/api/products?q=oil", lambda b: b["total"] == 2),
    ("quote 1000", "/api/pricing/quote?subtotal=1000&district=Dhaka",
     lambda b: (b["discount"], b["total"]) == (0, 1060)),
    ("quote 1001", "/api/pricing/quote?subtotal=1001&district=Dhaka",
     lambda b: (b["discount"], b["total"]) == (100, 961)),
]
# monitor(): 10 checks, 3 s apart, then exit;
# ALERT after 2 failed checks in a row, RESOLVED on the next pass

সত্যিকারের run: monitor চলার মাঝে একটি খারাপ release 1.2 পুরো “production”-এ যায়। এতে বসানো ভুল coupon_ge চালু, যা ১০০০ টাকাতেই ছাড় দেয়। তিনটি check পরে release-টি 1.1-এ ফেরানো হয়। Check-এর ব্যবধান এখানে ৩ সেকেন্ড, যাতে পুরো run আধা মিনিটে শেষ হয়; বাস্তবে সাধারণত এক থেকে কয়েক মিনিট।

$ python run_synthetic.py
check  1  PASS  http=[200]   94.7 ms
check  2  PASS  http=[200]  103.3 ms
check  3  PASS  http=[200]   52.5 ms
check  4  PASS  http=[200]  131.8 ms
          [release 1.2 deployed to all]
check  5  FAIL quote 1000  http=[200]  136.5 ms
check  6  FAIL quote 1000  http=[200]  110.7 ms  -> ALERT (2 failed checks in a row)
check  7  FAIL quote 1000  http=[200]   91.3 ms
          [rolled back to 1.1]
check  8  PASS  http=[200]   91.5 ms  -> RESOLVED
check  9  PASS  http=[200]   70.2 ms
check 10  PASS  http=[200]  122.7 ms
4check 4  PASS  http=[200]5check 5  FAIL quote 10006check 6  FAIL -> ALERT7check 7  FAIL, rollback8check 8  PASS -> RESOLVED
monitor-এর অবস্থা
release
discount@1000
ব্যর্থ পরপর
alert
  1. Check ৪. চারটি ধাপই ঠিক: ১০০০ টাকায় ছাড় ০, মোট ১০৬০; ১০০১-এ ছাড় ১০০, মোট ৯৬১. পরপর ব্যর্থ ০, কোনো alert নেই।
  2. Check ৫. Release 1.2 চালু। Health, search আর ১০০১-এর quote ঠিক, কিন্তু ১০০০ টাকায় ছাড় ১০০, নিয়মে যা ০ হওয়ার কথা। HTTP status তবু 200, latency স্বাভাবিক: কোনো error-ভিত্তিক dashboard লাল হয় না। পরপর ব্যর্থ ১; একবারের ব্যর্থতায় alert নয়, যাতে একটি নেটওয়ার্কের ঝাঁকুনি কাউকে রাতে না জাগায়।
  3. Check ৬. একই ব্যর্থতা আবার, পরপর ২: নিয়ম অনুযায়ী ALERT. Release থেকে alert পর্যন্ত দুটি check-এর সময়; ৫ মিনিটের ব্যবধানে এটি প্রায় ৫–১০ মিনিট হতো। ব্যবধান ছোট করলে সমস্যা দ্রুত ধরা পড়ে, কিন্তু production-এ check-এর নিজের ভারও বাড়ে।
  4. Check ৭, তারপর rollback. Alert চালু থাকে, কিন্তু প্রতিটি নতুন ব্যর্থতায় নতুন alert যায় না; একই ঘটনার জন্য একটি বার্তা যথেষ্ট। এর পরে 1.1-এ ফেরানো হলো।
  5. Check ৮. চারটি ধাপই আবার ঠিক, ছাড় ০; alert নিজে থেকে RESOLVED. Monitor দশটি check-এর পরে নিজে বন্ধ হলো; এটি একটি নির্দিষ্ট সংখ্যার run, অসীম লুপ নয়।

এই run-এর সবচেয়ে বড় শিক্ষা: পুরো সময়ে প্রতিটি HTTP status ছিল 200. Error rate, latency বা golden signals-এর কোনো সাধারণ dashboard এই release-কে খারাপ বলত না; শুধু একটি ব্যবসার নিয়মের assertion বলেছে। আগের অংশের canary-তে এর উল্টোটা: সব উত্তর সঠিক, শুধু ধীর। তাই production-এ নজরদারির দুটি স্তরই লাগে: প্রযুক্তিগত মাপ আর সংখ্যা মেলানো journey. Synthetic check-এর প্রচলিত খোলা উৎসের যন্ত্র: browser-এর পুরো journey-র জন্য Playwright-এর script (Apache-2.0), HTTP-র সাড়ার জন্য Prometheus-এর Blackbox exporter (Apache-2.0) কাজে লাগে। RUM-এ browser-এর মানক timing API আর web-vitals library (Apache-2.0) দিয়ে পাতার সময় সংগ্রহ হয়; সেই মাপগুলো পর্ব ৫১-এ (Frontend performance) দেখেছেন।

৮ · Observability tester-এর চোখে, আর production-এ chaos

Monitoring আগে থেকে জানা প্রশ্নের উত্তর দেয়: error rate কত, p95 কত। Observability হলো নতুন, আগে না ভাবা প্রশ্ন করার ক্ষমতা: “শুধু Chattogram-এর Plus সদস্যদের checkout কেন ধীর?” এর তিনটি উপাদান। Metric, সময়ের সাথে সংখ্যা (ক্লাউড ও DevOps কোর্সের পর্ব ৬৩)। Log, প্রতিটি ঘটনার বিবরণ; এই পর্বের proxy log যেমন, যেখানে নাম-সহ ঘর থাকায় backend বা endpoint ধরে ভাগ করা গেছে (একই কোর্সের পর্ব ৬৪)। Trace, একটি request-এর পুরো পথ সময়সহ, যাকে distributed tracing বলে; এর প্রচলিত মানক OpenTelemetry (Apache-2.0), আর বিস্তারিত একই কোর্সের পর্ব ৬৫-এ।

Tester এগুলো তিনভাবে ব্যবহার করেন। Bug report-এ প্রমাণ: production-এর একটি অভিযোগ নিয়ে trace id আর log-এর লাইন যোগ করলে developer অনুমান না করে কারণ দেখেন; পর্ব ১৮-এর (Bug report) প্রমাণের নিয়মের সাথে এটি মেলে। Test-এর oracle: canary analysis আর synthetic check আসলে observability-র data-র ওপর লেখা assertion. পরীক্ষাযোগ্যতার দাবি: নতুন feature-এর review-তে tester জিজ্ঞেস করেন, “এটি production-এ ভাঙলে আমরা কোন metric বা log-এ জানব?” উত্তর না থাকলে সেটি একটি অসম্পূর্ণ requirement. আর পর্ব ৫০-এর error budget এখানে ফিরে আসে: canary বা flag-এর পরীক্ষা বাজেট থেকে খরচ করে; বাজেট দ্রুত পুড়লে (burn rate বেশি) ঝুঁকিপূর্ণ rollout থামে। Burn-rate-ভিত্তিক alert ক্লাউড ও DevOps কোর্সের পর্ব ৬৬-এ আছে।

শেষ ধাপ chaos engineering: ইচ্ছা করে ব্যর্থতা ঢুকিয়ে দেখা, system প্রত্যাশামতো টেকে কি না। এর পদ্ধতি, hypothesis আর নিয়ন্ত্রিত পরীক্ষা পর্ব ৬৩-এর (Chaos আর resilience testing) বিষয়, আর বড় পরিসরের অনুশীলন ক্লাউড ও DevOps কোর্সের পর্ব ৬৮-এ। Production-এ chaos চালানো সবচেয়ে শেষের ধাপ, আর এর পূর্বশর্ত এই পর্বেরই guardrail: ছোট blast radius, পরিষ্কার থামার শর্ত, আর পরীক্ষিত rollback. যে দল একটি canary-কে স্বয়ংক্রিয়ভাবে ফেরাতে পারে না, তার production-এ chaos চালানোর সময় এখনো আসেনি।

আরও গভীরে: স্বয়ংক্রিয় canary analysis-এর একটি পরিচিত খোলা উৎসের উদাহরণ Kayenta (Apache-2.0), যা Netflix আর Google ২০১৮ সালের দিকে একসাথে প্রকাশ করে বলে উল্লেখ করা হয়; এটি অনেকগুলো metric-এ canary আর একটি নতুন চালু করা baseline-এর বণ্টন তুলনা করে (Mann-Whitney U-ধাঁচের পরীক্ষা) আর একটি সামগ্রিক নম্বর দেয়। লক্ষ করুন, তুলনা পুরোনো চলমান দলের সাথে নয়, একই সময়ে নতুন চালু করা একটি “baseline” কপির সাথে, যাতে দীর্ঘ সময় চলা process-এর cache আর memory-র পার্থক্য রায়ে না মেশে। Kubernetes-এ এই কাজ Argo Rollouts আর Flagger-এর মতো যন্ত্র (দুটিই Apache-2.0) ধাপে ধাপে চালায়। Online experiment-এর ফাঁদ নিয়ে Kohavi, Tang আর Xu-এর “Trustworthy Online Controlled Experiments” (২০২০) বইটি বহুল উদ্ধৃত।

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

  • Canary আর blue-green-এর মূল পার্থক্য? Blue-green সব traffic এক ধাপে নতুন দলে সরায়; canary ছোট ভাগে শুরু করে মাপ দেখে ধাপে ধাপে বাড়ায়।
  • Deploy আর release-এর পার্থক্য? Deploy মানে কোড production-এ বসানো; release মানে ব্যবহারকারীর জন্য খোলা, যা feature flag বা traffic-এর ভাগ দিয়ে আলাদা করা যায়।
  • Percentage rollout কেন hash দিয়ে, random দিয়ে নয়? একই ব্যবহারকারী প্রতিবার একই ফল পান, আর শতাংশ বাড়ালে আগে পাওয়া কেউ হারান না।
  • Synthetic monitoring আর RUM-এর পার্থক্য? Synthetic একটি লেখা journey নিয়মিত চালায়, ক্রেতা না থাকলেও; RUM আসল ব্যবহারকারীর অভিজ্ঞতা মাপে, কিন্তু আঘাতের পরে।
  • ১% canary-তে error বাড়েনি, তাহলে কি নিরাপদ? না-ও হতে পারে; নমুনা ছোট হলে পার্থক্য ধরার power কম, তাই সময় বা ভাগ বাড়াতে হয়।

৯ · AI-এর যুগে — AI দিয়ে rollout plan, flag আর monitor

AI সহকারী কয়েক সেকেন্ডে একটি canary plan, একটি flag-এর SDK-র কোড বা একটি synthetic script লিখে দিতে পারে। এই ক্ষেত্রে তার চেনা ভুলগুলো সরাসরি ক্রেতার ওপর পড়ে। সাধারণ ভুল: শুধু সুখী পথের (happy path) synthetic check, যা শুধু status 200 দেখে; বর্তমান আচরণকে “সঠিক” ধরে assertion লেখা, ফলে ভুল coupon-ও পাস করে; কল্পিত flag-এর SDK-র function বা proxy-র option; শতাংশের rollout-এ random(), যা উপরের test-এ ধরা পড়েছে; synthetic script-এ ক্রমাগত চলা while True আর sleep; canary-র রায় একটি মাত্র সংখ্যা থেকে, নমুনার আকার না দেখে; production-এ আসল ক্রেতার account বা আসল payment; আর না চালিয়েই “rollback কাজ করবে” দাবি।

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

তুমি একজন অভিজ্ঞ QA engineer. বাজারঘরের একটি synthetic monitor আর একটি canary analysis script লিখবে, Python-এর standard library দিয়ে। নিচে আমাদের business rule আর API-র অংশ দিলাম। নিয়ম: ১. Host শুধু http://127.0.0.1:8873; অন্য কোনো ঠিকানা লিখবে না। ২. প্রতিটি ধাপের assertion লিখিত rule থেকে নেবে (যেমন subtotal 1000-এ discount 0, 1001-এ 100), বর্তমান উত্তর থেকে নয়। ৩. Monitor নির্দিষ্ট সংখ্যক check চালিয়ে থামবে; while True লিখবে না। পরপর ২টি ব্যর্থতায় একটি alert, সফল হলে resolved. ৪. শুধু GET request; কোনো order বা payment নয়; header-এ শুধু নকল visitor id. ৫. Canary-র রায়ে নমুনার ন্যূনতম আকার, two-proportion z-test আর p95-এর দুই শর্ত থাকবে; প্রতিটি সীমা আলাদা constant-এ। ৬. তুমি কিছু চালাওনি; "কাজ করবে" দাবি করবে না, আর কোনো library-র নাম বানাবে না। [এখানে business rule আর API-র অংশ]

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

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

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

প্র ০১“Production-এ test করা” একসময় দায়িত্বহীনতার ঠাট্টা ছিল। আজ এটি একটি স্বীকৃত অনুশীলন কেন, আর কোথায় এর সীমা?

পুরোনো ঠাট্টাটি ছিল: “আমি সবসময় test করি না, কিন্তু যখন করি, production-এ করি।” এর পেছনের ভয় সত্যি ছিল: release-এর আগে না দেখে ক্রেতার ওপর পরীক্ষা চালানো। তাহলে বদলাল কী? প্রথমত, system-এর আকার। একটি দোকানের app এখন অনেকগুলো service, বাইরের সেবা আর হাজার রকম যন্ত্রের মিলন; staging-এ তার পুরো নকল বানানো প্রায় অসম্ভব আর খরচসাপেক্ষ। দ্বিতীয়ত, release-এর গতি: দিনে কয়েকবার deploy হলে প্রতিটির আগে সপ্তাহব্যাপী পরীক্ষা চলে না। তৃতীয়ত, যন্ত্র: traffic-এর সূক্ষ্ম ভাগ, feature flag আর ভালো observability এখন সাধারণ।

২০১৮ সালের দিকে Cindy Sridharan-এর একটি বহুল পঠিত প্রবন্ধ (“Testing in Production, the safe way”) এই ধারণাকে সাজিয়ে বলে, এমনটি উল্লেখ করা হয়: production-এর testing হলো deploy, release আর release-এর পরের ধাপে ভাগ করা অনেকগুলো কৌশল, যেমন shadow, canary, flag আর monitoring, আর প্রতিটির নিজস্ব ঝুঁকি। মূল যুক্তি হলো, production-এ সমস্যা আসবেই; প্রশ্ন শুধু, কতজন আঘাত পাবেন আর কত দ্রুত ধরা পড়বে।

সীমাও স্পষ্ট। যেখানে একটি ভুল অপরিবর্তনীয় ক্ষতি করে, যেমন চিকিৎসা যন্ত্র, বিমান বা টাকার স্থানান্তর, সেখানে release-এর পরে শেখার সুযোগ খুব সীমিত; সেখানে আগের যাচাই, নিয়ন্ত্রক মানদণ্ড আর formal পদ্ধতি প্রধান। আইন আর গোপনীয়তার প্রশ্ন আছে: আসল ক্রেতার data-য় পরীক্ষা অনুমতি আর নিয়মের মধ্যে থাকতে হয়। আর সাংগঠনিক সীমা: rollback-এর মহড়া, alert আর on-call না থাকলে “production-এ test” আবার পুরোনো ঠাট্টায় ফিরে যায়।

মূল উপলব্ধি: Production-এ testing দায়িত্বহীন হয় guardrail ছাড়া; ছোট পরিসর, আগে লেখা মাপ আর পরীক্ষিত ফেরার পথ থাকলে এটি release-এর আগের test-এর জাল পেরিয়ে আসা সমস্যা ধরার সবচেয়ে বাস্তব উপায়।

প্র ০২কয়লা খনির ক্যানারি পাখি থেকে ২০২৪ সালের একটি বিশ্বব্যাপী বিপর্যয় পর্যন্ত: ধাপে ধাপে release না করার মূল্য কী?

“Canary” নামটি এসেছে কয়লা খনি থেকে। খনিশ্রমিকরা খাঁচায় ক্যানারি পাখি নিয়ে নামতেন; বিষাক্ত গ্যাসে ছোট পাখিটি মানুষের আগে অসুস্থ হতো, আর সেটিই ছিল সতর্কসংকেত। ব্রিটেনের খনিতে এই প্রথা ১৯৮০-এর দশকে, ১৯৮৬ সালের দিকে, বন্ধ হয় বলে উল্লেখ করা হয়। সফটওয়্যারের canary একই ভূমিকা নেয়: ছোট একটি দল আগে নতুন version পায়, আর তাদের মাপ সবার জন্য সতর্কসংকেত।

ধাপে ধাপে না ছড়ালে কী হয়, তার একটি বহুল আলোচিত উদাহরণ ১৯ জুলাই ২০২৪. একটি নিরাপত্তা সফটওয়্যারের content update একসাথে বিপুল সংখ্যক Windows কম্পিউটারে পৌঁছায়, আর সেগুলো চালু হতে গিয়ে বারবার বন্ধ হয়ে যায়। Microsoft-এর হিসাবে প্রায় ৮৫ লাখ যন্ত্র আক্রান্ত হয় বলে জানানো হয়; বিমানবন্দর, হাসপাতাল আর ব্যাংকের কাজ ব্যাহত হয়। প্রতিষ্ঠানটির পরের বিশ্লেষণে যে প্রতিশ্রুতিগুলো ছিল, তার একটি হলো এই ধরনের update-ও ধাপে ধাপে, canary-র মতো করে ছড়ানো, আর গ্রাহককে সময় নিয়ন্ত্রণের সুযোগ দেওয়া।

এখান থেকে tester-এর জন্য কয়েকটি শিক্ষা। এক, “এটি তো কোড নয়, শুধু config বা data” কথাটি বিপজ্জনক; config, rule আর content update-ও কোডের মতো আচরণ বদলায়, তাই একই ধাপে ধাপে release আর একই test পাওয়ার যোগ্য। দুই, blast radius আগে থেকে সীমিত না থাকলে সবচেয়ে ভালো monitoring-ও শুধু দ্রুত জানায় যে সবাই আক্রান্ত। তিন, rollback-এর পথ নিজেই নির্ভর করতে পারে যে যন্ত্র চালু আছে; যন্ত্র চালুই না হলে দূর থেকে ফেরানো যায় না, তাই প্রথম ছোট দলে থামাই একমাত্র রক্ষা।

মূল উপলব্ধি: ধাপে ধাপে release হলো ক্ষতির পরিধির ওপর একটি সীমা; কোড, config বা content, যে বদলই আচরণ বদলায়, তাকে প্রথমে ছোট দলে পাঠানো আর মাপা দরকার।

প্র ০৩Feature flag deploy-কে নিরাপদ করে, তবু একটি পুরোনো flag ২০১২ সালে একটি প্রতিষ্ঠানকে ৪৫ মিনিটে প্রায় শেষ করে দিয়েছিল। Flag-এর অন্ধকার দিক কী?

১ আগস্ট ২০১২ তারিখে যুক্তরাষ্ট্রের শেয়ার বাজারের একটি বড় লেনদেন প্রতিষ্ঠান, Knight Capital, নতুন কোড আটটি server-এ বসায়। মার্কিন নিয়ন্ত্রক সংস্থা SEC-এর পরের প্রতিবেদন অনুযায়ী, একটি server-এ নতুন কোড পৌঁছায়নি। নতুন কোডে একটি পুরোনো flag-এর নাম নতুন কাজে আবার ব্যবহার হয়েছিল; সেই flag চালু হতেই ওই একটি server-এ বহু বছর অব্যবহৃত পুরোনো একটি কোড জেগে ওঠে, আর প্রায় ৪৫ মিনিট ধরে অনিয়ন্ত্রিত লেনদেন চালায়। ক্ষতি এত বড় ছিল যে প্রতিষ্ঠানটি টিকে থাকতে বাইরের সাহায্য নেয় আর পরে অন্য একটি প্রতিষ্ঠানের সাথে একীভূত হয়।

এই ঘটনার প্রতিটি অংশ এই পর্বের একটি শিক্ষা। Flag debt: পুরোনো কোড আর তার flag মোছা হয়নি, তাই তা জাগানোর সুযোগ থেকে গিয়েছিল। Flag-এর নামের পুনর্ব্যবহার: একই নাম দুই অর্থে, পুরোনো আর নতুন কোডে। Deploy-এর যাচাই নেই: আটটির একটি server পিছিয়ে ছিল, আর কোনো স্বয়ংক্রিয় যাচাই তা ধরেনি; এই পর্বের rollback-এর পরে “পরের request কোথায় গেল” মাপার মতো একটি সরল পরীক্ষা এখানে কাজে আসত। Kill switch নেই: ভুল আচরণ বন্ধের দ্রুত, পরীক্ষিত পথ ছিল না।

Pete Hodgson-এর ২০১৭ সালের দিকের একটি প্রবন্ধ (martinfowler.com-এ প্রকাশিত) flag-কে কয়েক ধরনে ভাগ করে: release-এর flag, experiment-এর flag, operations-এর flag (kill switch) আর অনুমতির flag; প্রতিটির আয়ু আলাদা। Release-এর flag কয়েক দিন বা সপ্তাহ বাঁচা উচিত, তারপর মোছা। Tester-এর ব্যবহারিক কাজ: প্রতিটি flag-এর মালিক আর মেয়াদ আছে কি না দেখা, মেয়াদোত্তীর্ণ flag-এর তালিকা release-এর checklist-এ রাখা, আর flag মোছার পরিবর্তনকেও সাধারণ পরিবর্তনের মতো test করা।

মূল উপলব্ধি: Flag একটি সুইচ, আর মোছা না হওয়া সুইচ ভবিষ্যতের একটি ফাঁদ; flag-এর জীবনচক্র, মালিক আর মেয়াদ test-এর পরিধির ভেতরে।

প্র ০৪Canary আর stable-এর দুটি সংখ্যা পাশাপাশি দেখে রায় দেওয়া কেন বিভ্রান্তিকর হতে পারে? একটি নির্ভরযোগ্য canary analysis-এর নকশা কেমন?

সবচেয়ে সরল canary-র রায় হলো: “canary-র error ০.৮%, stable-এর ০.৬%, তাই খারাপ”। এই পর্বের দুটি ব্লক দেখিয়েছে কেন এটি ভুল হতে পারে। একই আসল হারের দুটি ছোট নমুনা এলোমেলোভাবে আলাদা দেখায় (stable-এর ০.৩৯% আর ০.৬৫%, একই ০.৫% থেকে)। আর ১% canary-তে ১০০টি request থেকে একটি তিনগুণ খারাপ version-ও “প্রমাণ যথেষ্ট নয়” পায়। তাই রায়ের প্রথম শর্ত পরিসংখ্যান: পার্থক্য noise-এর চেয়ে বড় কি না, আর নমুনা যথেষ্ট কি না।

দ্বিতীয় সমস্যা তুলনার ভিত্তি। পুরোনো stable দল ঘণ্টার পর ঘণ্টা চলছে; তার cache গরম, memory স্থির। নতুন canary সদ্য চালু, cache ঠান্ডা। তাই পার্থক্যের একটি অংশ version-এর নয়, বয়সের। এই কারণে Netflix আর Google-এর Kayenta-র মতো পদ্ধতিতে (২০১৮ সালের দিকে প্রকাশিত বলে উল্লেখ করা হয়) canary-র পাশে একই সময়ে পুরোনো version-এর একটি নতুন “baseline” কপি চালু করা হয়, আর তুলনা হয় এই দুই সমবয়সী দলের মধ্যে। তৃতীয় সমস্যা দলের গঠন: canary-তে শুধু একটি অঞ্চলের ক্রেতা গেলে পার্থক্য ক্রেতার, কোডের নয়।

চতুর্থ, একাধিক metric. Error, latency, CPU, ব্যবসার সংখ্যা মিলে কয়েক ডজন তুলনা হলে কেবল দৈবক্রমেও কয়েকটি “লাল” আসবে। তাই হয় প্রতিটির সীমা কড়া, নয়তো metric-কে গুরুত্ব অনুযায়ী ভাগ করা: কয়েকটি “অবশ্যই ভালো” আর বাকিগুলো সামগ্রিক নম্বরে। পঞ্চম, সময়: বারবার দেখে প্রথম লাল মুহূর্তে থামানো মিথ্যা alarm বাড়ায়। এই পর্বের নিয়মের তিনটি অংশ, ন্যূনতম নমুনা, পরিসংখ্যানের পরীক্ষা আর দুই শর্তের সীমা, এই সমস্যাগুলোর সরল উত্তর।

মূল উপলব্ধি: নির্ভরযোগ্য canary analysis একই সময়ের সমবয়সী দলের তুলনা, যথেষ্ট নমুনা, noise মেনে লেখা সীমা আর আগে থেকে ঠিক করা সময়; দুটি সংখ্যা পাশাপাশি রাখা তার শুরু মাত্র।

প্র ০৫২০০৮ সালের একটি chat feature-এর “dark launch” থেকে আজকের shadow traffic: ব্যবহারকারীকে কিছু না দেখিয়ে production-এ test করার সুবিধা আর বিপদ কী?

২০০৮ সালে Facebook তাদের web chat চালুর আগে একটি পদ্ধতির কথা প্রকৌশল ব্লগে লেখে বলে উল্লেখ করা হয়: chat-এর পর্দা দেখানোর আগেই ব্যবহারকারীর browser পেছনে chat server-এর সাথে যোগাযোগ চালাত, যাতে আসল ভারে server কেমন আচরণ করে তা মাপা যায়। এর নাম দেওয়া হয় dark launch. সুবিধা স্পষ্ট: load test যত ভালোই হোক, আসল ব্যবহারকারীর আসল আচরণের নকল সে নয়; dark launch আসল ঢেউ আর আসল data দেয়, অথচ কেউ কিছু দেখেন না।

আজকের shadow traffic একই ধারণার আরেক রূপ: আসল অনুরোধের কপি নতুন version-এ যায়, উত্তর ফেলে দেওয়া হয়, আর পুরোনো ও নতুন উত্তর মিলিয়ে দেখা হয়। একটি search-এর নতুন algorithm বা database-এর নতুন query-র জন্য এটি দারুণ: পার্থক্যের তালিকাই একটি বিশাল, স্বয়ংক্রিয় regression test, আসল input দিয়ে।

বিপদ তিনটি। প্রথমত, side effect: shadow-এ যাওয়া অনুরোধ যদি লেখে, টাকা কাটে, SMS পাঠায় বা গুদামের হিসাব বদলায়, তাহলে ছায়া বাস্তব হয়ে যায়। তাই shadow সাধারণত শুধু পড়ার অনুরোধে, বা লেখার পথ নকল সেবায় ঘুরিয়ে। দ্বিতীয়ত, দ্বিগুণ ভার: shadow-এর কপি database আর বাইরের সেবায় বাড়তি চাপ দেয়, যা আসল ক্রেতাকে ধীর করতে পারে; তাই ভাগ ছোট আর নজরদারিসহ। তৃতীয়ত, গোপনীয়তা: আসল অনুরোধের কপিতে ক্রেতার তথ্য থাকে; সেই data কে দেখবে, কতদিন রাখা হবে, পরীক্ষার log-এ কী থাকবে, এসব আগে থেকে ঠিক করা আর আইন মেনে চলা জরুরি। আর কোন পার্থক্য প্রত্যাশিত (যেমন নতুন ranking) আর কোনটি bug, সেই নিয়ম আগে না লিখলে পার্থক্যের তালিকা অর্থহীন।

মূল উপলব্ধি: ব্যবহারকারীকে না দেখিয়ে production-এ চালানো আসল ভার আর আসল input দেয়; তবে side effect বন্ধ, ভার সীমিত আর ব্যক্তিগত তথ্য সুরক্ষিত না হলে “অদৃশ্য” test-ও দৃশ্যমান ক্ষতি করে।

অনুশীলন

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

  1. Spec থেকে test case: বাজারঘরের নতুন feature: “Plus সদস্যদের জন্য ঢাকার বাইরে delivery ৬০ টাকার বদলে ৪০ টাকা। এটি flag plus_delivery_40-এর পেছনে থাকবে; flag-এর ভাগ সদস্যের user id-র hash থেকে; flag-এর সেটিং পড়া না গেলে পুরোনো নিয়ম (৬০)। ঢাকার ভেতরের নিয়ম বদলাবে না।” Flag আর rollout-এর জন্য অন্তত ছয়টি test case লিখুন: অবস্থা, input আর প্রত্যাশিত ফল।

    একটি সম্ভাব্য সেট (rafi Plus সদস্য, Rajshahi; sumi Plus নন, Chattogram; mitu Dhaka):

    TC1 flag off            rafi, Rajshahi        -> delivery 60
    TC2 flag on, 100%       rafi, Rajshahi        -> delivery 40
    TC3 flag on, 100%       sumi (not Plus)       -> delivery 120
    TC4 flag on, 100%       Plus member in Dhaka  -> normal Dhaka rule (60, or 0 at >= 2000)
    TC5 flag file unreadable, rafi                -> delivery 60 (safe default)
    TC6 flag on, 10% -> 50% same user ids, twice  -> same answer each time;
                                                     nobody who had 40 goes back to 60
    TC7 kill switch (on=false) while server runs  -> next request 60, no restart

    কেন এগুলো: TC1–TC2 flag-এর দুই অবস্থা; TC3 আর TC4 নিশ্চিত করে নতুন নিয়ম অন্যদের ছোঁয় না (পর্ব ০৯-এর decision table-এর মতো প্রতিটি শর্তের জোড়া); TC5 নিরাপদ ডিফল্ট, যা প্রায়ই বাদ পড়ে; TC6 hash-এর স্থিরতা আর একমুখী বৃদ্ধি; TC7 kill switch আসলে কাজ করে কি না। উৎসাহী উত্তরে একটি TC8 থাকতে পারে: checkout-এর quote আর order-এর মোট দাম দুই জায়গাতেই ৪০, যাতে পর্দা আর বিল আলাদা না হয়।

  2. রায় অনুমান করুন: একটি canary analysis-এর নিয়ম: canary-তে অন্তত ২০০ request; error-এ একদিকের two-proportion z-test, p < ০.০১ এবং পার্থক্য ০.৫ শতাংশ-বিন্দুর বেশি হলে FAIL; p95-এ canary > ১.২৫ × stable এবং পার্থক্য > ২৫ ms হলে FAIL. তিনটি run: (ক) stable ৯,০০০ request, ৩৬টি error, p95 ৮০ ms; canary ১,০০০ request, ৪টি error, p95 ৯৫ ms. (খ) stable ২০,০০০, ৪০টি error, p95 ৬০; canary ২,০০০, ১৬টি error, p95 ৭০. (গ) stable ৪,৯০০, ০ error, p95 ৩০; canary ১৫০, ০ error, p95 ৪০০. প্রতিটির রায় আর exit code কী?

    (ক) error-এর হার দুদিকেই ০.৪% (৩৬/৯,০০০ আর ৪/১,০০০), z = ০, p = ০.৫; p95 ৯৫ > ১.২৫ × ৮০ = ১০০? না, ৯৫ < ১০০. রায় PASS, exit 0. (খ) হার ০.২% বনাম ০.৮%; pooled হার ৫৬/২২,০০০ ≈ ০.২৫৫%, z ≈ ৫.০৮, p ≈ ০.০০০০০০১৯; পার্থক্য ০.৬ শতাংশ-বিন্দু > ০.৫. তাই FAIL: error rate higher; p95 ৭০ < ৭৫, তাই latency-তে কিছু নেই; exit 1 আর rollback. (গ) canary-তে মাত্র ১৫০ request, তাই প্রথম শর্তে FAIL: too few canary requests (150); সাথে p95 ৪০০ > ৩৭.৫ এবং +৩৭০ > ২৫, তাই latency-ও FAIL; exit 1. লক্ষ করুন, এই script “নমুনা কম”-কেও FAIL ধরে, আর তাতেও rollback হয়: এটি সাবধানী নকশা; কিছু দল এর বদলে “অপেক্ষা করো, আরও data আনো” রায় দেয়। সংখ্যাগুলো এই পর্বের নিয়মে একটি ছোট script দিয়ে যাচাই করা।

  3. এই synthetic monitor-এ ভুল খুঁজুন: একজন সহকর্মীর লেখা পরিকল্পনা; অন্তত পাঁচটি সমস্যা খুঁজুন।
    Synthetic check, বাজারঘর production
    Account: mitu's real customer account (her password in the script)
    Every 1 minute, forever (while True + sleep(60))
    Journey: login → add oil to cart → place order → pay with mobile wallet
    Check: every response is HTTP 200 → PASS
    Alert: SMS to the whole team on EVERY failed check
    Orders created by the check: "we'll clean up at month end"

    (১) আসল ক্রেতার account আর পাসওয়ার্ড: একজন আসল মানুষের তথ্য আর গোপন পাসওয়ার্ড script-এ; চিহ্নিত test account আর গোপন তথ্যের নিরাপদ ভান্ডার দরকার। (২) আসল payment: প্রতি মিনিটে আসল order আর আসল wallet-এ টাকা; test account-এর payment সবসময় নকল gateway বা test mode-এ। (৩) শুধু HTTP 200: এই পর্বের run-এ সব 200 থেকেও coupon ভুল ছিল; প্রতিটি ধাপে ব্যবসার নিয়মের assertion লাগে। (৪) প্রতিটি ব্যর্থতায় সবাইকে SMS: একটি নেটওয়ার্কের ঝাঁকুনিতেই সবাই জাগবেন, আর একই ঘটনায় শত বার্তা; পরপর ২টি ব্যর্থতায় একটি alert, on-call-এর কাছে, আর সমাধানে একটি “resolved”. (৫) মাসের শেষে পরিষ্কার: মাসে প্রায় ৪৩,০০০টি নকল order গুদাম, রিপোর্ট আর হিসাব নষ্ট করবে; প্রতিটি test order দ্রুত বাতিল আর রিপোর্ট থেকে বাদ। (৬) stock-এ প্রভাব: প্রতি order-এ তেলের stock কমে, আসল ক্রেতা “স্টকে নেই” দেখতে পারেন। (৭) while True: monitor একটি পরিচালিত সেবা বা scheduler-এ চলা উচিত, থামানো আর নজর রাখা যায় এমনভাবে।

  4. Rollout-এর পরিকল্পনা আর হিসাব: বাজারঘরে মিনিটে গড়ে ১,২০০ request আসে, আর checkout-এর স্বাভাবিক error-এর হার ০.৫%. একটি নতুন version-এ হার ১.৫% হলে তা ধরতে প্রতিটি দলে প্রায় ১,৯৮৬টি request লাগে, যেখানে α = ০.০১ আর power ৮০ শতাংশ। (ক) Canary ৫%-এ রাখলে কত মিনিট লাগবে? (খ) ২০%-এ? (গ) একটি ধাপের পরিকল্পনা লিখুন: কোন শতাংশ, কতক্ষণ, কোন শর্তে পরের ধাপ।

    (ক) ৫% মানে মিনিটে ৬০টি request canary-তে; ১,৯৮৬ ÷ ৬০ ≈ ৩৩ মিনিট। (খ) ২০% মানে মিনিটে ২৪০টি; ১,৯৮৬ ÷ ২৪০ ≈ ৮.৩ মিনিট, কিন্তু ঝুঁকিতে চার গুণ বেশি ক্রেতা। (গ) একটি যুক্তিসঙ্গত পরিকল্পনা: প্রথমে কর্মীদের জন্য (internal) ১৫ মিনিট; তারপর ১% আর ১০ মিনিট, শুধু “বড় ক্ষতির” দ্রুত নিয়ম (যেমন error ৫%-এর বেশি বা p95 দ্বিগুণ হলে সাথে সাথে rollback); তারপর ৫% আর ৩৫–৪০ মিনিট, পূর্ণ পরিসংখ্যানের রায়সহ; তারপর ২৫%, ৫০% আর ১০০%, প্রতিটিতে কিছুক্ষণ আর synthetic journey সবুজ থাকার শর্তে। প্রতিটি ধাপের শর্ত, সময় আর rollback-এর পথ আগে লেখা থাকে, আর error budget দ্রুত পুড়লে পুরো rollout থামে। সংখ্যাগুলো এই পর্বের sample-size ব্লকের সূত্রে যাচাই করা।

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

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

ক্রমএকটি নতুন version-এর canary rollout-এর যুক্তিসঙ্গত ক্রম সাজান (▲▼ চেপে সরান)

  1. রায়ের নিয়ম আর rollback-এর পথ লিখে রাখা — কোন metric, কোন সীমা, কত নমুনা
  2. নতুন version deploy, কিন্তু শূন্য traffic
  3. ছোট একটি ভাগ (যেমন ১০%) hash-ভিত্তিক sticky ভাগে নতুন version-এ পাঠানো
  4. একই সময়ের দুই দলের error rate আর latency তুলনা করে রায়
  5. FAIL হলে ভাগ ০ করা আর পরের request কোথায় যায় তা মেপে যাচাই
  6. PASS হলে ধাপে ধাপে ভাগ বাড়ানো, প্রতি ধাপে আবার রায়

একটি নতুন version প্রথমে ৫% ব্যবহারকারীর কাছে যায়, মাপ ভালো থাকলে ২৫%, ৫০% আর ১০০%. এই কৌশলের নাম কী?

  • Blue-green deployment
  • Canary release
  • Shadow traffic
  • Rolling deployment

একটি canary-তে ৬০ সেকেন্ডে stable-এর error ০/৪,৬৬৫ আর p95 ৩৩.৫ ms; canary-র error ০/৫২৫ আর p95 ২২২.৫ ms. নিয়ম: p95-এ canary > ১.২৫ × stable এবং পার্থক্য > ২৫ ms হলে FAIL; error-এর নিয়মও আছে। সঠিক রায় কোনটি?

  • PASS, কারণ দুদিকেই কোনো error নেই
  • রায় দেওয়া যায় না, নমুনা খুব ছোট
  • FAIL, latency-র কারণে; rollback
  • FAIL, error rate-এর কারণে

একটি feature flag-এর percentage rollout লেখা হয়েছে এভাবে: প্রতিটি request-এ random() * 100 < percent. মূল সমস্যা কী?

  • একই ব্যবহারকারী ভিন্ন request-এ ভিন্ন ফল পান, আর শতাংশ বাড়ালে আগের কেউ হারাতে পারেন
  • মোট ভাগ সেটিং থেকে অনেক দূরে থাকে
  • Kill switch কাজ করে না
  • random() খুব ধীর, তাই latency বাড়ে

একটি release-এর পরে সব endpoint HTTP 200 দিচ্ছে, error rate আর latency স্বাভাবিক, কিন্তু ১০০০ টাকার কার্টে ভুল করে ১০০ টাকা ছাড় যাচ্ছে (নিয়মে ০)। কোন নজরদারি এটি সবচেয়ে আগে ধরবে?

  • Error rate-এর dashboard
  • /api/health-এর health check
  • p95 latency-র alert
  • ব্যবসার নিয়মের assertion-সহ synthetic journey

একই খারাপ version (আসল error-এর হার ০.৫% থেকে ১.৫%) মোট ১০,০০০ request-এর ১%-এ, অর্থাৎ ১০০টি request-এ, পরীক্ষা হলো; canary-তে ১টি error, z-test-এ p = ০.৩৩. সবচেয়ে সঠিক সিদ্ধান্ত কোনটি?

  • Canary নিরাপদ প্রমাণিত, ১০০%-এ খোলা যায়
  • প্রমাণ যথেষ্ট নয়; নমুনা বাড়াতে সময় বা ভাগ বাড়াতে হবে
  • Canary খারাপ প্রমাণিত, এখনই rollback
  • Error-এর তুলনায় statistics কাজে আসে না

বাজারঘরের একটি production synthetic check পরিকল্পনা হচ্ছে, যা checkout আর payment-এর পথও যাচাই করবে। কোন নিয়মটি সবচেয়ে জরুরি?

  • একজন সক্রিয় আসল ক্রেতার account ব্যবহার, যাতে পথটি বাস্তব হয়
  • প্রতি ১০ সেকেন্ডে check, যাতে কিছুই না ফসকায়
  • চিহ্নিত test account, নকল payment-এর পথ, আর test order রিপোর্ট থেকে বাদ ও দ্রুত বাতিল
  • শুধু HTTP status দেখা, যাতে check সরল থাকে

শব্দকোষ

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

মনে রাখুন

  1. Production-এ testing guardrail-সহ: ছোট blast radius, আগে লেখা মাপ, পরীক্ষিত rollback আর side effect বন্ধ; এটি release-এর আগের test-এর বদলি নয়।
  2. Canary-র রায় সংখ্যায়: সত্যিকারের run-এ error শূন্য থেকেও p95 ৩৪ → ২২২ ms-এ FAIL, ভাগ ০, আর পরের ১,৩৫৩টি request-এর সবই stable-এ; rollback-ও মেপে দেখা হয়।
  3. Statistics আর সময়: একই খারাপ version ১০%-এ ধরা পড়ে, ১%-এ “প্রমাণ যথেষ্ট নয়”; ০.৫% → ১.৫% ধরতে প্রতি দলে প্রায় ২,০০০ request.
  4. Flag deploy আর release আলাদা করে: hash-ভিত্তিক ভাগ স্থির আর একমুখী; kill switch restart ছাড়া বন্ধ করে; মেয়াদ শেষে flag মুছুন, নইলে flag debt.
  5. Synthetic check সংখ্যা মেলায়: সব 200 থেকেও ভুল coupon ধরা পড়ল দ্বিতীয় ব্যর্থ check-এ; RUM আসল অভিজ্ঞতা দেখায়, observability নতুন প্রশ্নের উত্তর দেয়।

পরের পর্বে: Test report আর metric — JUnit XML-কে সাধারণ ভাষা ধরে অনেক run-এর ফল জোড়া, Allure-এর রিপোর্ট আর ইতিহাস, আর কোন metric সত্যিই অর্থবহ, কোনটি শুধু দেখতে সুন্দর।

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

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