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

IoT cloud আর device management — provisioning, telemetry আর OTA update

IoT Cloud and Device Management — Provisioning, Telemetry and OTA Updates

Taught in Bangla, this lesson manages a fleet across its whole lifecycle. It provisions devices by challenge-response, rejects a fake key, and on a local amqtt broker on 127.0.0.1 with paho-mqtt ingests board telemetry into a time-series table without duplicates, with min, max and average rollups. A 2 s keep-alive Last Will raises an offline alert at 3.0 s. OTA images are checked by size and SHA-256 into A/B slots with trial boot and rollback, and a staged rollout stops when failures pass a limit.

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

  • একটি IoT যন্ত্রের জীবনচক্র আর প্রতিটি ধাপে cloud-এর কোন সেবা লাগে, তা আঁকতে পারা
  • প্রতিটি যন্ত্রের আলাদা পরিচয়, key, certificate আর challenge-response দিয়ে provisioning ব্যাখ্যা করা
  • Telemetry-কে duplicate ছাড়া time-series database-এ রাখা, downsampling আর retention নকশা করা
  • Keep-alive, heartbeat আর Last Will দিয়ে offline ধরা, আর সর্বোচ্চ কত দেরিতে ধরা পড়বে তা হিসাব করা
  • A/B slot-এ OTA update, image যাচাই, rollback আর বহরে ধাপে ধাপে rollout-এর নিয়ম লেখা

১ · একটি যন্ত্র থেকে একটি বহর — device management কেন লাগে

বাজারঘরে এখন একটি নয়, অনেক যন্ত্র: কয়েকটি smart scale, ঠান্ডা ঘরের monitor, গুদামের gateway. ধরুন ব্যবসা বাড়ল, দশটি দোকানে দুশো scale. তখন প্রশ্নগুলো বদলে যায়। নতুন scale বাক্স থেকে বের করে কীভাবে বিশ্বাস করবেন এটি আপনার যন্ত্র, নকল নয়? কোন scale কোন দোকানে, কোন firmware-এ চলছে, কে জানবে? কোনোটি চুপ হয়ে গেলে কতক্ষণে টের পাবেন? আর দামের হিসাবে একটি ভুল ধরা পড়লে দুশোটি scale-এ কীভাবে নতুন firmware পাঠাবেন, যাতে কোনোটি অচল না হয়? এই প্রশ্নগুলোর উত্তরের নামই fleet management বা device management. এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….

পর্ব ৭০-এ আপনি একটি reading-এর পথ আর device shadow দেখেছেন; MQTT-র topic, QoS, retained বার্তা আর Last Will-এর ভেতরের কথা পর্ব ৭৩-এ। এখানে তার ওপরে দাঁড়িয়ে পুরো বহরের দেখাশোনা। Security-র পুরো threat model আসবে পর্ব ৭৬-এ, আর signed firmware, secure boot ও anti-rollback পর্ব ৭৭-এ; এখানে শুধু ধারণাটুকু, যেখানে দরকার।

উপমা — রিকশা গ্যারেজের মালিক: একজন মালিকের দুশো রিকশা। প্রতিটির একটি লাইসেন্স নম্বর আর খাতায় একটি পাতা (registry). নতুন চালক এলে আগে পরিচয় যাচাই, তারপর রিকশা হাতে (provisioning). প্রতিদিন সন্ধ্যায় হিসাব জমা (telemetry). কোনো রিকশা তিন দিন ফেরেনি মানে খোঁজ নিতে হবে (heartbeat আর offline alert). নতুন ধরনের ব্রেক লাগানোর আগে দুটি রিকশায় পরীক্ষা, তারপর দশটিতে, তারপর সবগুলোতে; আর পুরোনো ব্রেক ফেলে দেওয়া হয় না, যতক্ষণ নতুনটি ঠিক প্রমাণ না হয় (staged rollout আর rollback).

নিচের ছবিতে একটি যন্ত্রের জীবনচক্র। প্রতিটি অবস্থায় cloud-এর একটি আলাদা সেবা কাজ করে: provisioning service, device registry, telemetry-র database, monitor আর OTA service. বাস্তব cloud সেবার নাম ইচ্ছে করে বসানো হয়নি; বড় cloud প্রতিষ্ঠানগুলোর IoT সেবায় এই অংশগুলো বিভিন্ন নামে থাকে।

ছবি ৭৫.১ — একটি IoT যন্ত্রের জীবনচক্র

ওপর থেকে নিচে: কারখানা থেকে বাতিল পর্যন্ত; মাঝের তিনটি অবস্থার মধ্যে যন্ত্র বারবার যাওয়া-আসা করে

IoT যন্ত্রের জীবনচক্র ১ · কারখানায় তৈরি serial, key · manufactured ২ · Provisioning পরিচয় যাচাই → active ৩ · Active: কাজ চলছে telemetry · heartbeat · config OTA update slot B → confirm Offline Last Will → alert ৪ · Decommission key বাতিল · registry থেকে বাদ ব্যর্থ হলে slot A-তে ফেরা
ছবি ৭৫.১ — প্রতিটি বাক্সে cloud-এর একটি সেবা দায়িত্বে: provisioning service (২), registry আর telemetry-র database (৩), OTA service (বাঁয়ে), monitor (ডানে)। মাঝখানের সোজা তীরটি যন্ত্রের জীবনের শেষ: বাতিল করার সময় তার key-ও বাতিল করতে হয়, নইলে পুরোনো যন্ত্রের পরিচয় চুরি করে কেউ বহরে ঢুকতে পারে।

মূল নিয়ম একটি যন্ত্রের জন্য যা হাতে করা যায়, দুশোটির জন্য তা স্বয়ংক্রিয় আর যাচাইযোগ্য হতে হবে: প্রতিটি যন্ত্রের আলাদা পরিচয়, প্রতিটি বার্তায় seq, প্রতিটি অবস্থার একটি সময়, আর প্রতিটি পরিবর্তনের একটি ফেরার পথ।

২ · Provisioning — যন্ত্রের পরিচয় আর প্রথম সংযোগ

Provisioning মানে নতুন যন্ত্রকে প্রথমবার কাজের উপযোগী করা: তাকে একটি পরিচয় দেওয়া, সেই পরিচয় cloud-এ নথিভুক্ত করা, আর তাকে বলে দেওয়া কোথায় কী পাঠাবে। এর কেন্দ্রে একটি প্রশ্ন: cloud কীভাবে নিশ্চিত হবে যে “আমি BG-SC-0002” বলা যন্ত্রটি সত্যিই সেই scale?

পরিচয়ের দুটি প্রচলিত পথ। প্রথমটি certificate-ভিত্তিক: যন্ত্রের ভেতরে একটি private key তৈরি হয় বা বসানো হয়, আর তার public key-সহ একটি X.509 certificate-এ একটি certificate authority (CA) সই করে। সংযোগের সময় mTLS-এ যন্ত্র certificate দেখায় আর private key দিয়ে প্রমাণ দেয় key তার কাছেই আছে। দ্বিতীয়টি symmetric key-ভিত্তিক: যন্ত্র আর cloud দুজনেই একটি গোপন key জানে। Certificate আর CA-র তত্ত্ব Cybersecurity পর্ব ১১-এ, আর TLS Computer Networks পর্ব ৪৮-এ।

প্রতিটি যন্ত্রের key আলাদা হতেই হবে। সব scale-এ একই password থাকলে একজন একটি scale খুলে flash পড়লেই সবার password জেনে যায়। আলাদা key বানানোর একটি পরিচিত কৌশল: কারখানায় একটি গোপন group key থেকে প্রতিটি serial-এর জন্য key বের করা, key = HMAC-SHA256(group key, serial). Microsoft-এর Azure DPS-এর নথিতে enrollment group-এর symmetric key দিয়ে ঠিক এভাবে registration ID-এর HMAC-SHA256 নিয়ে “derived device key” বানানোর কথা আছে, আর বলা আছে group key যন্ত্রে রাখা যাবে না। আরেকটি পথ AWS IoT-এর “provisioning by claim”: একটি ব্যাচের যন্ত্রে স্বল্পমেয়াদি একটি claim certificate থাকে, যা প্রথম সংযোগে প্রতিটি যন্ত্রের নিজস্ব certificate আর key-এর সঙ্গে বদলে নেওয়া হয় (নথি অনুযায়ী; খুঁটিনাটি সেবাভেদে আলাদা)।

Key কখনো তারে যায় না। যন্ত্র key পাঠালে পথে কেউ তা কপি করতে পারে। তাই cloud একটি নতুন এলোমেলো সংখ্যা পাঠায়, একটি nonce; যন্ত্র key দিয়ে তার HMAC বানিয়ে ফেরত দেয়; cloud নিজের দিকে একই হিসাব করে মেলায়। এই পদ্ধতির নাম challenge-response. প্রতিবার nonce নতুন বলে পুরোনো উত্তর আবার পাঠিয়ে (replay) কাজ হয় না। নিচের কোডটি চালিয়ে দেখুন:

# Provisioning: প্রতিটি device-এর আলাদা key, আর challenge-response দিয়ে পরিচয় যাচাই
import hashlib, hmac, random

GROUP_KEY = b"FAKE-bazarghar-factory-group-key-not-real"   # নকল, শেখার জন্য

def device_key(serial):                  # কারখানায় একবার, device-এর flash-এ
    return hmac.new(GROUP_KEY, serial.encode(), hashlib.sha256).digest()

def proof(key, nonce):                   # device যা পাঠায়; key নিজে কখনো যায় না
    return hmac.new(key, nonce.encode(), hashlib.sha256).hexdigest()

registry = {"BG-SC-0001": "active", "BG-SC-0002": "manufactured"}
rng = random.Random(75)                  # নির্দিষ্ট seed: প্রতিবার একই nonce

def provision(serial, key, old_proof=None):
    if serial not in registry:
        return "REJECT unknown serial", None
    nonce = "%016x" % rng.getrandbits(64)            # প্রতিবার নতুন challenge
    p = old_proof or proof(key, nonce)
    if not hmac.compare_digest(p, proof(device_key(serial), nonce)):
        return f"REJECT proof mismatch (nonce {nonce})", p
    registry[serial] = "active"
    return f"OK nonce {nonce} proof {p[:16]}...", p

print("key BG-SC-0002:", device_key("BG-SC-0002").hex()[:16], "... (32 byte)")
ok, p1 = provision("BG-SC-0002", device_key("BG-SC-0002"))
print("1 আসল scale     :", ok)
print("2 ভুল key-এর নকল:", provision("BG-SC-0002", b"FAKE-wrong-key")[0])
print("3 পুরোনো proof   :", provision("BG-SC-0002", None, old_proof=p1)[0])
print("4 অচেনা serial  :", provision("BG-SC-0099", device_key("BG-SC-0099"))[0])
print("registry:", registry)

আসল আউটপুট (ব্রাউজারের Python):

key BG-SC-0002: c893fa75cd92f326 ... (32 byte)
1 আসল scale     : OK nonce 95b5582a736a9625 proof af236aab9eadbd64...
2 ভুল key-এর নকল: REJECT proof mismatch (nonce 7450bc566fc64ccb)
3 পুরোনো proof   : REJECT proof mismatch (nonce ba9289f30aa88e0e)
4 অচেনা serial  : REJECT unknown serial
registry: {'BG-SC-0001': 'active', 'BG-SC-0002': 'active'}

চারটি ঘটনা চারটি শিক্ষা। আসল scale-এর proof মেলে, কারণ cloud group key থেকে একই device key বানাতে পারে। নকল যন্ত্রটি serial ঠিক বললেও key জানে না, তাই proof মেলে না। তৃতীয় চেষ্টায় কেউ আগের সফল proof হুবহু পাঠিয়েছে, কিন্তু nonce বদলে গেছে (ba9289f30aa88e0e), তাই replay ব্যর্থ। আর registry-তে নেই এমন serial-কে challenge-ই দেওয়া হয়নি। hmac.compare_digest সময়-সমান তুলনা করে, যাতে কতগুলো অক্ষর মিলল তা সময় মেপে আন্দাজ করা না যায়। Seed নির্দিষ্ট রাখা হয়েছে শুধু আউটপুট একই রাখতে; আসল nonce আসে নিরাপদ এলোমেলো উৎস থেকে (Python-এ secrets).

একই নিয়ম এবার আমার lab-এ সত্যিকারের MQTT-র ওপর চালানো হলো: reference lab-এর mqtt_demo.py-র amqtt broker (127.0.0.1-এ, port চলার সময় বাছা হয় আর কোথাও ছাপা হয় না; Spec decision 37), একটি provisioning service আর একটি SQLite registry. bazarghar/provision/… topic-গুলো এই পর্বের নিজের নকশা, reference lab-এর Spec decision 38-এর অংশ নয়। সৎ থাকার জন্য: lab-এর broker anonymous আর TLS ছাড়া (Spec decision 37); আসল ব্যবস্থায় provisioning-এর সংযোগও TLS-এ হয়।

সত্যিকারের run — amqtt 0.12.2 + paho-mqtt 2.2.0, Python 3.13.5
~/lab/fleet $ python -B fleet_demo.py prov
broker: amqtt on 127.0.0.1 (port chosen at run time)

registry before:
    serial      device_id   model     rev  fw     state
    BG-CR-0001  coldroom-1  coldroom  A    1.0.0  active
    BG-SC-0001  scale-1     scale     A    1.0.0  active
    BG-SC-0002  -           scale     A    1.0.0  manufactured

1. BG-SC-0002: new scale, factory key
    service -> challenge nonce 95b5582a736a9625
    device  -> proof HMAC-SHA256(key, nonce) = af236aab9eadbd64...
    service -> result {"ok":true,"device_id":"scale-2","pub":"bazarghar/scale/2/weight","config_version":1}

2. BG-SC-0002: clone with the wrong key
    service -> challenge nonce 7450bc566fc64ccb
    device  -> proof HMAC-SHA256(key, nonce) = 745806eed3d8f57a...
    service -> result {"ok":false,"why":"proof mismatch"}

3. BG-SC-0099: serial not in the registry
    service -> result {"ok":false,"why":"unknown serial"}

registry after:
    serial      device_id   model     rev  fw     state
    BG-CR-0001  coldroom-1  coldroom  A    1.0.0  active
    BG-SC-0001  scale-1     scale     A    1.0.0  active
    BG-SC-0002  scale-2     scale     A    1.0.0  active

broker stopped

Nonce আর proof ব্রাউজারের কোডের সঙ্গে হুবহু মেলে, কারণ দুই জায়গায় একই seed আর একই HMAC. নতুন scale ফল হিসেবে পেয়েছে তিনটি জিনিস: তার নাম (scale-2), সে কোন topic-এ লিখবে, আর config-এর version. এবার প্রতিটি ধাপ আলাদা করে দেখুন।

BG-SC-0002, কারখানা থেকে active
ধাপ
Device জানে
বার্তা
Registry
  1. কারখানা। Serial আর group key থেকে HMAC-SHA256 দিয়ে 32 byte-এর device key বানিয়ে flash-এ লেখা হয়; registry-তে serial ওঠে manufactured অবস্থায়। Group key কারখানার নিরাপদ যন্ত্রেই থাকে, scale-এ যায় না।
  2. প্রথম চালু। Scale দোকানে পৌঁছে network পেয়ে নিজের serial আর firmware version জানায়। এখনো তার কোনো নাম বা topic নেই।
  3. Challenge. Service registry-তে serial খুঁজে পায়, আর একটি নতুন 64-bit nonce 95b5582a736a9625 পাঠায়। এই nonce শুধু এই একবারের জন্য।
  4. Proof. Scale key দিয়ে nonce-এর HMAC বানায়, শুরু af236aab9eadbd64. Key নিজে তারে যায়নি; পথে কেউ এই proof দেখলেও পরের বার তা কাজে লাগবে না।
  5. যাচাই। Service group key আর serial থেকে নিজে device key বানায়, একই HMAC হিসাব করে, আর সময়-সমান তুলনায় মেলায়। মিলেছে; nonce মুছে ফেলা হয়।
  6. ফল। Registry-তে BG-SC-0002 এখন active, নাম scale-2. Scale পেয়েছে topic bazarghar/scale/2/weight আর config version 1; এখন থেকে সে বহরের সদস্য।

৩ · Registry আর telemetry — time-series database-এ জমা

Device registry হলো বহরের খাতা: প্রতিটি যন্ত্রের serial, নাম, মডেল, hardware revision, firmware version, অবস্থা আর শেষ কবে দেখা গেছে। এই খাতা ছাড়া পরের সব কাজ অন্ধ: কোন যন্ত্রে update পাঠাবেন, কোনটি চুপ, কোনটি পুরোনো hardware-এর। Telemetry যায় অন্য জায়গায়, একটি time-series database-এ, যেখানে প্রতিটি সারি “কোন যন্ত্র, কোন সময়, কোন মাপ, কত”.

আমার lab-এ পথটি সত্যিই চালানো হলো: reference lab-এর virtual board-এ scale.elf আর coldroom.elf চলেছে (BG-M3, আসল Cortex-M chip-এর আদলে বানানো virtual board, Spec decision 17), একটি bridge তাদের UART লাইন MQTT-তে প্রকাশ করেছে, আর একটি ingest service সেই বার্তা SQLite-এ লিখেছে। Board-এ radio নেই, তাই device আর gateway-এর মাঝের wireless link-এর জায়গায় UART লাইন আর bridge. Scale-এর UART লাইন থেকে JSON বানানো হয়েছে reference lab-এর scale_payload() দিয়ে, যা firmware-এর হিসাবই করে।

# ingest service: MQTT বার্তা -> SQLite time series (127.0.0.1)
db.execute("create table telemetry(dev text, seq int, board_ms real,"
           " metric text, value real, primary key(dev, seq, metric))")
ing = md.Client("ingest", port, log)
ing.connect()
ing.subscribe("bazarghar/+/+/weight", 1)
ing.subscribe("bazarghar/+/+/temp", 1)
...
d = json.loads(payload)
if "temp_c" in d:
    db.execute("insert or ignore into telemetry values (?,?,?,?,?)",
               (d["dev"], d["seq"], t_ms, "temp_c", d["temp_c"]))
else:
    for k in ("net_g", "price_paisa"):
        db.execute("insert or ignore into telemetry values (?,?,?,?,?)",
                   (d["dev"], d["seq"], t_ms, k, d[k]))
সত্যিকারের run — amqtt 0.12.2 + paho-mqtt 2.2.0, Python 3.13.5; board.py (BG-M3, virtual)
~/lab/fleet $ python -B fleet_demo.py ingest
broker: amqtt on 127.0.0.1 (port chosen at run time)
[   100.0889 ms] bazarghar/scale/1/weight   {"dev":"scale-1","seq":1,"gross_g":0,"tare_g":0,"net_g":0,"rate_paisa_per_kg":6550,"price_paisa":0}
[   300.0978 ms] bazarghar/scale/1/weight   {"dev":"scale-1","seq":2,"gross_g":150,"tare_g":0,"net_g":150,"rate_paisa_per_kg":6550,"price_paisa":983}
[   500.0981 ms] bazarghar/scale/1/weight   {"dev":"scale-1","seq":3,"gross_g":150,"tare_g":150,"net_g":0,"rate_paisa_per_kg":6550,"price_paisa":0}
[   700.1125 ms] bazarghar/scale/1/weight   {"dev":"scale-1","seq":4,"gross_g":1400,"tare_g":150,"net_g":1250,"rate_paisa_per_kg":6550,"price_paisa":8188}
[  1100.1043 ms] bazarghar/scale/1/weight   {"dev":"scale-1","seq":5,"gross_g":650,"tare_g":150,"net_g":500,"rate_paisa_per_kg":6550,"price_paisa":3275}
[ 10000.1104 ms] bazarghar/coldroom/1/temp  {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}
[ 20000.1097 ms] bazarghar/coldroom/1/temp  {"dev":"coldroom-1","seq":2,"temp_c":-0.50,"alarm":"LOW"}
duplicate seq 2 from coldroom-1: rows inserted = 0

rows: 12
    coldroom-1  temp_c       n=2 min=-0.5 max=7
    scale-1     net_g        n=5 min=0 max=1250
    scale-1     price_paisa  n=5 min=0 max=8188
latest price: scale-1 seq 5 at 1100.1043 ms = 3275 paisa

broker stopped

সংখ্যাগুলো reference README-এর বাজারঘরের হিসাবের সঙ্গে হুবহু মেলে: 150 g-এ 983 paisa (9.83 টাকা), 1250 g net-এ 8188 paisa (81.88 টাকা), 500 g-এ 3275 paisa (32.75 টাকা); 5100 g-এর OVERLOAD লাইনটি ওজনের বার্তা নয় বলে database-এ ওঠেনি। সবচেয়ে গুরুত্বপূর্ণ লাইনটি rows inserted = 0: cold room-এর seq 2 দ্বিতীয়বার এলে (QoS 1-এ PUBACK হারালে এমন হয়) primary key (dev, seq, metric) তাকে ঢুকতে দেয়নি। একই বার্তা দুবার লিখলেও ফল একই, অর্থাৎ লেখাটি idempotent; এটিই deduplication-এর সবচেয়ে সরল আর নির্ভরযোগ্য রূপ।

Time-series database-এর দ্বিতীয় সমস্যা আকার। প্রতি সেকেন্ডের reading বছরের পর বছর রাখা যায় না, তাই পুরোনো কাঁচা মান ছোট সারাংশে নামানো হয় (downsampling), আর কাঁচা মান একটি নির্দিষ্ট সময় পরে মোছা হয় (data retention). নিচের কোডে cold room-এর board run-এর ২০টি আসল reading (প্রতি 1 s-এ একটি; reference README-এর coldroom আউটপুট থেকে):

# Time-series: cold room-এর ২০টি reading (board-এর আসল run) SQLite-এ, তারপর 10 s-এর সারাংশ
import sqlite3

temps = [4.00, 4.00, 5.50, 5.50, 8.25, 9.00, 9.50, 9.50, 7.75, 7.00,   # t = 1..10 s
         7.00, 7.00, 7.00, 7.00, -0.50, -0.50, -0.50, -0.50, -0.50, -0.50]
db = sqlite3.connect(":memory:")
db.execute("""create table reading(dev text, t_s int, temp_c real,
              primary key (dev, t_s))""")          # একই (dev, সময়) দুবার ঢোকে না
rows = [("coldroom-1", t, v) for t, v in enumerate(temps, start=1)]
db.executemany("insert into reading values (?, ?, ?)", rows)
dup = db.execute("insert or ignore into reading values ('coldroom-1', 10, 7.00)")
print("rows:", db.execute("select count(*) from reading").fetchone()[0],
      "| duplicate inserted:", dup.rowcount)

# downsampling: প্রতি 10 s-এর window-এ গড়, সর্বনিম্ন, সর্বোচ্চ
q = """select (t_s - 1) / 10 * 10 as w, count(*), round(avg(temp_c), 3),
              min(temp_c), max(temp_c),
              sum(temp_c > 8.0), sum(temp_c < 0.0)
       from reading group by w order by w"""
print("window   n   avg     min    max   >8.00  <0.00")
for w, n, avg, lo, hi, high, low in db.execute(q):
    print(f"{w:2}-{w + 10:2} s {n:3} {avg:7.3f} {lo:6.2f} {hi:6.2f} {high:5} {low:6}")

# retention: পুরোনো কাঁচা reading মুছে শুধু সারাংশ রাখা
db.execute("create table rollup as " + q.replace("order by w", ""))
gone = db.execute("delete from reading where t_s <= 10").rowcount
print("raw deleted:", gone, "| raw left:",
      db.execute("select count(*) from reading").fetchone()[0],
      "| rollup rows:", db.execute("select count(*) from rollup").fetchone()[0])

আসল আউটপুট (ব্রাউজারের Python):

rows: 20 | duplicate inserted: 0
window   n   avg     min    max   >8.00  <0.00
 0-10 s  10   7.000   4.00   9.50     4      0
10-20 s  10   2.500  -0.50   7.00     0      6
raw deleted: 10 | raw left: 10 | rollup rows: 2

প্রথম window-এর গড় ঠিক 7.000 °C. শুধু গড় রাখলে মনে হবে ঠান্ডা ঘর সীমার ভেতরেই ছিল, অথচ চারটি reading 8.00 °C-এর ওপরে আর সর্বোচ্চ 9.50 °C, যা alarm চালু করেছিল। তাই সারাংশে গড়ের পাশে সর্বনিম্ন, সর্বোচ্চ আর সীমা পেরোনো reading-এর সংখ্যাও রাখতে হয়। দ্বিতীয় window-এর গড় 2.500 °C-ও একই রকম বিভ্রান্তিকর: সেখানে ৬টি reading 0.00 °C-এর নিচে। Retention-এর পরে প্রথম ১০ সেকেন্ডের কাঁচা মান নেই, কিন্তু সারাংশের একটি সারি আছে; বড় database-এ সাধারণত কয়েক দিনের কাঁচা মান আর কয়েক বছরের সারাংশ রাখা হয়। Metric-এর তত্ত্ব আর বড় মাপের monitoring Cloud & DevOps পর্ব ৬৩-এ।

৪ · নির্দেশ আর config — উল্টো পথে বার্তা

Telemetry যায় যন্ত্র থেকে cloud-এ; নির্দেশ আর config আসে উল্টো পথে। পর্ব ৭০-এ device shadow-এর মডেল দেখেছেন: মালিক যা চান (desired) আর যন্ত্র যা জানিয়েছে (reported), আর দুইয়ের পার্থক্যই যন্ত্রের করণীয়। বহরের মাপে এর সঙ্গে তিনটি নিয়ম যোগ হয়।

১ · Config-এর version

প্রতিটি config-এ একটি বাড়তে থাকা নম্বর (config_version, provisioning-এর ফলে 1). যন্ত্র জানায় “আমি version 3 প্রয়োগ করেছি”; cloud দেখে কোনগুলো এখনো পুরোনোয়।

২ · Idempotent নির্দেশ

“সীমা হবে 8.50” নির্দেশ দুবার এলেও ফল একই; “সীমা 0.5 বাড়বে” দুবার এলে সীমা 1.0 বেড়ে যায়, যা ভুল। QoS 1-এ বার্তা দুবার আসতে পারে, তাই নির্দেশ লেখা হয় শেষ অবস্থা হিসেবে।

৩ · ঘুমন্ত যন্ত্র

Battery-র যন্ত্র বেশিরভাগ সময় ঘুমায় (পর্ব ৬০). তাই config রাখা হয় retained বার্তা বা shadow-এ; যন্ত্র জেগে উঠে নিজে টেনে নেয়।

একটি নিয়ম বিশেষভাবে মনে রাখুন: নিরাপত্তার সীমা, যেমন ঠান্ডা ঘরের 8.00 °C, দূর থেকে বদলানোর ক্ষমতা নিজেই একটি ঝুঁকি। যন্ত্রের firmware তাই প্রতিটি config যাচাই করে (যেমন সীমা একটি যুক্তিসংগত পরিসরে কি না), আর অযৌক্তিক মান ফিরিয়ে দিয়ে reported-এ কারণ লেখে। কে কোন নির্দেশ দিতে পারবেন, সেই অনুমতির প্রশ্ন পর্ব ৭৬-এ।

৫ · বেঁচে আছে কি না — keep-alive, heartbeat আর Last Will

দুশো যন্ত্রের মধ্যে একটি চুপ হয়ে গেলে কেউ তা নিজে থেকে লক্ষ করবে না; ব্যবস্থাকেই জানাতে হবে। দুটি স্তরে এটি করা হয়। MQTT-র স্তরে, CONNECT-এ client একটি keep-alive সময় বলে দেয়; MQTT 3.1.1 (অংশ 3.1.2.10) অনুযায়ী broker তার দেড় গুণ সময়ে client-এর কাছ থেকে কোনো packet না পেলে সংযোগ ভেঙে দেয়, যেন network ব্যর্থ হয়েছে। আর সংযোগ DISCONNECT ছাড়া ভাঙলে broker client-এর জমা রাখা Last Will প্রকাশ করে। তিনটি ঘটনা আমার lab-এ সত্যিই চালানো হলো, keep-alive 2 s রেখে:

সত্যিকারের run — amqtt 0.12.2 + paho-mqtt 2.2.0, Python 3.13.5
~/lab/fleet $ python -B fleet_demo.py heartbeat
broker: amqtt on 127.0.0.1 (port chosen at run time)

A. silent: no packets, no TCP close (keep-alive 2 s)
    monitor <- online
    monitor <- offline 3.0 s after the device's last packet -> ALERT coldroom-1 offline

B. program crash: the OS closes TCP without DISCONNECT
    monitor <- online
    monitor <- offline 0.0 s after the TCP close -> ALERT coldroom-1 offline

C. clean DISCONNECT (planned restart)
    monitor <- online
    monitor: no status message within 8.0 s (Last Will discarded)

broker stopped

ঘটনা A সবচেয়ে বাস্তব: যন্ত্রের বিদ্যুৎ চলে গেলে বা radio-র পথ হারালে TCP সংযোগ বন্ধের কোনো খবর broker-এ পৌঁছায় না, packet শুধু আসা বন্ধ হয়। তখন keep-alive-ই একমাত্র উপায়: 2 s × 1.5 = 3 s পরে broker সংযোগ ভেঙে Last Will offline প্রকাশ করেছে। ঘটনা B-তে একটি program crash করেছে কিন্তু তার operating system সংযোগ বন্ধ করেছে, তাই broker সঙ্গে সঙ্গে জেনেছে; Linux gateway-এ এমন হয়, ছোট MCU-তে প্রায় কখনো নয়। ঘটনা C-তে যন্ত্র নিয়মমতো DISCONNECT পাঠিয়েছে, আর MQTT-র নিয়মে তখন Last Will মুছে যায়; পরিকল্পিত restart-এর আগে যন্ত্রকে তাই নিজেই offline লিখতে হয়, নইলে dashboard পুরোনো online দেখাবে। সময়গুলো wall-clock-এ মাপা, প্রতিটি run-এ সামান্য বদলাতে পারে; 3.0 s আর 0.0 s দুটি run-এই একই এসেছে।

MQTT-র keep-alive শুধু বলে TCP সংযোগ বেঁচে আছে। কিন্তু gateway-এর পেছনের একটি scale, বা যার firmware আটকে গেছে কিন্তু network stack চলছে, তার খবর তাতে নেই। তাই application স্তরে একটি heartbeat থাকে: যন্ত্র নিয়মিত একটি ছোট “আমি আছি” বার্তা পাঠায়, সঙ্গে firmware version আর uptime. Monitor পরপর কয়েকটি না পেলে alert দেয়। কেন “পরপর কয়েকটি”? একটি বার্তা হারানো স্বাভাবিক; প্রতিটি হারানোয় alert দিলে মানুষ alert-কে অবহেলা করতে শেখে।

# Heartbeat monitor: প্রতি 60 s-এ একটি heartbeat; পরপর ৩টি না এলে offline alert
PERIOD, MISSED = 60, 3
LIMIT = PERIOD * MISSED                   # 180 s চুপ থাকলে offline

beats = {
    "scale-1":    list(range(0, 601, 60)),                  # সব ঠিক
    "scale-2":    [t for t in range(0, 601, 60) if t != 180],  # একটি হারাল
    "coldroom-1": [t for t in range(0, 601, 60) if t <= 240]
                + [t for t in range(480, 601, 60)],          # 240 s-এর পরে চুপ, 480 s-এ ফিরল
}
last = {d: None for d in beats}
state = {d: "online" for d in beats}
gone = {}                                  # offline হওয়ার আগের শেষ heartbeat

for now in range(0, 601, 30):             # monitor প্রতি 30 s-এ দেখে
    for dev, times in beats.items():
        if now in times:
            last[dev] = now
            if state[dev] == "offline":
                state[dev] = "online"
                print(f"t={now:3} s  RECOVERED {dev} (চুপ ছিল {now - gone[dev]} s)")
        silent = now - last[dev]
        if state[dev] == "online" and silent > LIMIT:
            state[dev] = "offline"
            gone[dev] = last[dev]
            print(f"t={now:3} s  ALERT {dev} offline: শেষ heartbeat t={last[dev]} s,"
                  f" {silent} s আগে")

print("শেষ অবস্থা:", state)
print("scale-2-এর সবচেয়ে বড় ফাঁক:",
      max(b - a for a, b in zip(beats["scale-2"], beats["scale-2"][1:])), "s -> alert নেই")

আসল আউটপুট (ব্রাউজারের Python):

t=450 s  ALERT coldroom-1 offline: শেষ heartbeat t=240 s, 210 s আগে
t=480 s  RECOVERED coldroom-1 (চুপ ছিল 240 s)
শেষ অবস্থা: {'scale-1': 'online', 'scale-2': 'online', 'coldroom-1': 'online'}
scale-2-এর সবচেয়ে বড় ফাঁক: 120 s -> alert নেই

scale-2-এর একটি heartbeat হারিয়েছে, ফাঁক 120 s, যা 180 s-এর সীমার ভেতরে: কোনো মিথ্যা alert নেই। cold room-এর শেষ heartbeat 240 s-এ, কিন্তু alert এসেছে 450 s-এ, 210 s পরে, সীমার চেয়ে 30 s বেশি। কারণ monitor প্রতি 30 s-এ দেখে, আর 420 s-এ চুপ থাকার সময় ঠিক 180 s, যা সীমার “বেশি” নয়। নকশার সময় তাই সর্বোচ্চ দেরি লিখুন: সীমা + monitor-এর দেখার বিরতি। নিচের stepper-এ cold room-এর ঘটনাটি ধাপে ধাপে।

Monitor প্রতি 30 s-এ যা দেখে
Monitor-এর সময়
শেষ heartbeat
চুপ থাকার সময়
সীমা 180 s পার?
অবস্থা
  1. শুরু। cold room প্রতি 60 s-এ heartbeat পাঠায়; প্রথমটি 0 s-এ। চুপ থাকার সময় 0 s, অবস্থা online.
  2. 240 s: শেষ heartbeat. এরপর cold room চুপ (ধরুন gateway-এর সঙ্গে তার RS-485 তার খুলে গেছে)। Monitor এখনো কিছু জানে না।
  3. 300 s: একটি হারাল। 60 s চুপ, মানে একটি heartbeat আসেনি। একটি হারানো স্বাভাবিক হতে পারে, তাই এখনো alert নয়।
  4. 420 s: ঠিক সীমায়। 180 s চুপ, তিনটি heartbeat হারিয়েছে, কিন্তু নিয়ম “180 s-এর বেশি”. সমান হলে alert নয়; এক ধাপ দেরি এখানেই।
  5. 450 s: ALERT. 210 s চুপ, সীমা পার। Monitor একবারই alert পাঠায় আর অবস্থা offline রাখে, যাতে প্রতি 30 s-এ নতুন alert না যায়।
  6. 480 s: ফিরে আসা। নতুন heartbeat এল; অবস্থা online, আর “চুপ ছিল 240 s” লেখা থাকে। মাঝের telemetry gateway-এর store-and-forward থেকে পরে আসতে পারে (পর্ব ৭০)।

৬ · OTA update — A/B slot, image যাচাই আর rollback

OTA update হলো তার না জুড়ে, network দিয়ে firmware বদলানো। এর সবচেয়ে বড় ভয়: update-এর মাঝে বিদ্যুৎ গেলে বা নতুন image-এ ভুল থাকলে যন্ত্র অচল হয়ে যাওয়া, আর দুশো দোকানে লোক পাঠিয়ে ঠিক করতে হওয়া। এর প্রচলিত সমাধান A/B partition: flash-এ দুটি slot, A-তে চলমান firmware, B-তে নতুনটি নামে। পুরোনোটি না মুছেই নতুনটি লেখা হয়, তাই মাঝপথে বিদ্যুৎ গেলেও A অক্ষত।

নামানোর পরে, চালানোর আগে যাচাই। Cloud প্রতিটি নতুন image-এর জন্য একটি firmware manifest প্রকাশ করে: মডেল, version, আকার আর SHA-256 hash. আমার lab-এ reference lab-এর আসল scale firmware (Clang 22.1.8-এ build করা) zig objcopy -O binary দিয়ে raw image বানানো হলো, আর যন্ত্রের দিকের পরীক্ষাগুলো চালানো হলো। শেখার জন্য এই image-কেই নতুন version 1.1.0 ধরা হয়েছে:

সত্যিকারের run — ziglang 0.17.1 (objcopy), Python 3.13.5
~/lab/fleet $ python -m ziglang objcopy -O binary ../_ref/firmware/build/scale.elf ota/scale-1.0.0.bin
~/lab/fleet $ python -B ota_check.py
manifest: {"model":"scale","version":"1.1.0","min_hw_rev":"A","size":2188,"sha256":"0e76e66985e6b743d1c893729f9c44fb70e5c90892629209977ad72c7e122b08"}
chunks of 256 byte: 9
1. all chunks arrive      : OK  MSP=0x20005000 reset=0x08000341 (Thumb bit set) -> mark slot B, reboot
2. chunk 5 lost           : REJECT size 1932 != 2188
3. one bit flipped at 1000: REJECT sha256 7c7e2bb80bc2... != 0e76e66985e6...
4. image for another model: REJECT size 1848 != 2188

Image মাত্র 2188 byte, 256 byte-এর ৯টি টুকরোয় আসে। চারটি পরীক্ষা চারটি ভিন্ন বিপদ ধরে। একটি টুকরো হারালে আকার মেলে না। একটি মাত্র bit উল্টালে hash পুরো বদলে যায় (7c7e2bb8… বনাম 0e76e669…): এটিই hash function-এর ধর্ম। ভুল মডেলের image (cold room-এর 1848 byte) আকারেই ধরা পড়েছে; আকার মিলে গেলেও hash ধরত। শেষ পরীক্ষাটি vector table: image-এর প্রথম শব্দ stack-এর শুরু 0x20005000 আর দ্বিতীয়টি reset handler 0x08000341, যার শেষ bit 1 মানে Thumb কোড (পর্ব ৩২, পর্ব ৩১)। এখানে image 0x08000000-এর জন্য link করা; আসল A/B ব্যবস্থায় slot B-র image হয় তার নিজের ঠিকানার জন্য link করা হয়, নয়তো bootloader slot অদলবদল করে।

সতর্কতা: SHA-256 শুধু বলে image পথে বদলায়নি; বলে না image-টি কে বানিয়েছে। আক্রমণকারী নিজের image আর তার সঠিক hash-সহ একটি manifest পাঠালে এই পরীক্ষা পাস করবে। তাই আসল OTA-তে manifest-এ নির্মাতার digital signature থাকে, আর যন্ত্র তার public key দিয়ে যাচাই করে। Signature, secure boot আর পুরোনো version-এ ফেরানো আটকানো (anti-rollback) পর্ব ৭৭-এর বিষয়।

যাচাইয়ের পরে চালানো, কিন্তু পরীক্ষামূলকভাবে। একটি পরিচিত নকশা (MCUboot নামের খোলা bootloader-এর নথিতে বর্ণিত “test” upgrade এর একটি রূপ): bootloader নতুন image একবার চালায়; নতুন firmware নিজের health check করে, যেমন sensor পড়া যায় কি না আর broker-এ যুক্ত হওয়া যায় কি না, আর সফল হলে নিজেকে “confirmed” চিহ্নিত করে। Confirm না করেই reset হলে, যেমন crash-এর পরে watchdog-এর reset (পর্ব ৬১), bootloader পুরোনো slot-এ ফেরে। এই ফেরার নাম rollback. যন্ত্র তারপর cloud-কে জানায় “1.1.0 ব্যর্থ, 1.0.0-এ ফিরেছি”, যা পরের অংশের rollout-এর সিদ্ধান্তের কাঁচামাল।

৭ · বহরের মাপে — ধাপে ধাপে rollout

একটি ভুল update একসাথে দুশো যন্ত্রে গেলে দুশোটিই সমস্যায় পড়ে। তাই update ছাড়া হয় ধাপে ধাপে, যার নাম staged rollout: প্রথমে অল্প কয়েকটি যন্ত্রে (canary), তারপর বেশি, তারপর সবগুলোতে। প্রতিটি ধাপের পরে ফল দেখে সিদ্ধান্ত: এগোনো, না থামা। নিচের কোডে বাজারঘরের ২০০টি scale-এর একটি কল্পিত বহর: প্রতি পঞ্চমটি পুরোনো hardware revision B-র, মোট ৪০টি, আর version 1.1.0-এ এমন একটি ভুল যা শুধু rev B-র ADC-তে ধরা পড়ে।

# OTA staged rollout: ২০০টি scale, ধাপে ধাপে; কোনো ধাপে ব্যর্থতা 5%-এর বেশি হলে থামা
import random

rng = random.Random(8)                    # নির্দিষ্ট seed: প্রতিবার একই বহর
fleet = [f"scale-{i}" for i in range(1, 201)]
rev = {d: ("B" if i % 5 == 0 else "A") for i, d in enumerate(fleet, 1)}  # ৪০টি rev B
rng.shuffle(fleet)                        # কোন ধাপে কে, এলোমেলো

def install(dev, version):                # A/B: নতুন image slot B-তে, boot, health check
    healthy = not (version == "1.1.0" and rev[dev] == "B")   # 1.1.0-এ rev B-র ADC ভুল
    return "ok" if healthy else "rollback"                  # ব্যর্থ হলে slot A-তে ফেরা

def rollout(version, waves=(2, 10, 50, 138), max_fail=0.05):
    todo = fleet
    done = 0
    print(f"--- {version}: {len(todo)}টি device, ধাপ {waves}")
    for n, size in enumerate(waves, 1):
        wave = todo[done:done + size]
        if not wave:
            break
        res = [install(d, version) for d in wave]
        fail = res.count("rollback")
        done += len(wave)
        print(f"ধাপ {n}: {len(wave):3}টি, ok {res.count('ok'):3}, rollback {fail:2}"
              f" ({fail / len(wave):.0%}) | মোট নতুন version-এ {done - fail}")
        if fail / len(wave) > max_fail:
            print(f"   থামানো হলো: {fail / len(wave):.0%} > {max_fail:.0%}; বাকি"
                  f" {len(todo) - done}টি পুরোনো version-এই থাকল")
            return
    print("   সম্পূর্ণ")

rollout("1.1.0")
rollout("1.1.1")                          # rev B-র ভুল ঠিক করা নতুন version

আসল আউটপুট (ব্রাউজারের Python):

--- 1.1.0: 200টি device, ধাপ (2, 10, 50, 138)
ধাপ 1:   2টি, ok   2, rollback  0 (0%) | মোট নতুন version-এ 2
ধাপ 2:  10টি, ok   9, rollback  1 (10%) | মোট নতুন version-এ 11
   থামানো হলো: 10% > 5%; বাকি 188টি পুরোনো version-এই থাকল
--- 1.1.1: 200টি device, ধাপ (2, 10, 50, 138)
ধাপ 1:   2টি, ok   2, rollback  0 (0%) | মোট নতুন version-এ 2
ধাপ 2:  10টি, ok  10, rollback  0 (0%) | মোট নতুন version-এ 12
ধাপ 3:  50টি, ok  50, rollback  0 (0%) | মোট নতুন version-এ 62
ধাপ 4: 138টি, ok 138, rollback  0 (0%) | মোট নতুন version-এ 200
   সম্পূর্ণ

প্রথম ধাপের দুটি scale-ই rev A, তাই canary ভুলটি ধরতে পারেনি: ছোট canary সব ধরনের যন্ত্র ছোঁয় না। দ্বিতীয় ধাপে একটি rev B scale rollback করেছে, ব্যর্থতা 10%, সীমা 5% পার, rollout থেমেছে। ক্ষতি: একটি scale কয়েক মিনিটের জন্য, আর সেটিও নিজে slot A-তে ফিরেছে। না থামলে কী হতো, একই seed-এ গুনে দেখা হয়েছে (আমার lab-এ, Python 3.13.5): তৃতীয় ধাপে আরও ৮টি আর চতুর্থে ৩১টি, মোট ৪০টি rev B-র সবগুলো। ভুল ঠিক করা 1.1.1 চারটি ধাপেই পাস করে ২০০টিতে পৌঁছেছে।

২০০টি scale-এর বহর
Version
এই ধাপে
ok / rollback
নতুন version-এ
সিদ্ধান্ত
  1. Manifest. OTA service 1.1.0-এর manifest প্রকাশ করে: আকার, SHA-256, কোন মডেল। এখনো কোনো যন্ত্র নতুন version-এ নেই।
  2. ধাপ ১ (canary). ২টি scale নতুন image slot B-তে নামায়, যাচাই করে, পরীক্ষামূলক boot করে, health check পাস করে confirm করে। দুটিই rev A; ব্যর্থতা 0%, তাই এগোনো।
  3. ধাপ ২. ১০টির মধ্যে scale-200 rev B: নতুন firmware-এর health check-এ ADC-র মান অযৌক্তিক, confirm হয় না, reset-এর পরে bootloader slot A-তে ফেরে। ৯টি ok, মোট নতুন version-এ ১১টি।
  4. থামানো। ধাপ ২-এ ব্যর্থতা 10%, সীমা 5% পার। বাকি ১৮৮টি scale 1.0.0-এই থাকে, কিছুই জানে না। দল scale-200-এর রিপোর্ট পড়ে বোঝে ভুলটি শুধু rev B-তে।
  5. 1.1.1: ধাপ ১–৩. ভুল ঠিক করা version আবার ছোট থেকে শুরু: ২, ১০, ৫০, সব ধাপে rollback 0; মোট ৬২টি নতুন version-এ।
  6. 1.1.1: ধাপ ৪. বাকি ১৩৮টিও পাস; বহরের ২০০টি scale এখন 1.1.1-এ। Registry প্রতিটির firmware version হালনাগাদ করে, যা heartbeat-এর বার্তা থেকে মেলানো যায়।

বাস্তব rollout-এ আরও কয়েকটি নিয়ম কাজে লাগে। প্রথম ধাপে ইচ্ছে করে প্রতিটি hardware revision আর প্রতিটি ধরনের network থেকে যন্ত্র রাখা, যাতে canary সত্যিই প্রতিনিধিত্ব করে। দোকান খোলা থাকার সময় scale-এ update না করা: বাজারঘরের scale-এ রাতে, ক্রেতা না থাকলে। আর প্রতিটি যন্ত্র একই সেকেন্ডে image চাইলে server-এর ওপর চাপ, তাই সময়ের সঙ্গে খানিকটা এলোমেলো দেরি যোগ করা, ঠিক exponential backoff-এর মতো। Server-এর দিকের rolling, blue-green আর canary-র তুলনা Cloud & DevOps পর্ব ৫৯-এ; যন্ত্রের পার্থক্য হলো, যন্ত্র ভাঙলে ফেরানোর জন্য কেউ পাশে নেই, তাই rollback-এর পথ যন্ত্রের ভেতরেই থাকতে হয়।

আরও গভীরে: নিরাপদ update-এর গবেষণায় একটি প্রভাবশালী কাজ The Update Framework (TUF), যার সূচনা ২০১০ সালের দিকের একটি গবেষণাপত্রে (Samuel, Mathewson, Cappos ও Dingledine) বলে সাধারণত উল্লেখ করা হয়; এতে কয়েকটি আলাদা ভূমিকার key থাকে, যাতে একটি key চুরি হলেই পুরো ব্যবস্থা ভাঙে না। গাড়ির জন্য এর একটি রূপ Uptane. Hardware-এর দিকে অনেক যন্ত্র private key রাখে একটি আলাদা secure element chip-এ, যেখান থেকে key পড়া যায় না, শুধু তা দিয়ে সই করানো যায়। দুটির বিস্তারিত পর্ব ৭৬ আর ৭৭-এ।

পরীক্ষা ও ইন্টারভিউতে: “IoT provisioning-এ প্রতিটি যন্ত্রের আলাদা key কেন?” → একটি যন্ত্র খুলে key পেলে শুধু সেটিই ঝুঁকিতে, পুরো বহর নয়; বাতিলও করা যায় একটি একটি করে। “MQTT keep-alive 60 s হলে broker কখন সংযোগ ভাঙে?” → 1.5 × 60 = 90 s কোনো packet না পেলে, তারপর Last Will. “পরিষ্কার DISCONNECT-এ Last Will কি প্রকাশ হয়?” → না, মুছে যায়। “A/B partition-এর লাভ?” → update-এর মাঝে বিদ্যুৎ গেলেও পুরোনো firmware অক্ষত, আর নতুনটি ব্যর্থ হলে ফেরা যায়। “Staged rollout-এ কেন থামার নিয়ম?” → ভুল update-এর ক্ষতি প্রথম ছোট ধাপেই সীমিত রাখতে।

৮ · AI-এর যুগে device management যাচাই

“আমার IoT যন্ত্রের জন্য OTA আর provisioning বানিয়ে দিন” বললে AI assistant প্রায়ই চলনসই দেখতে কোড দেয়, যার ভুল ধরা পড়ে শুধু দুশো যন্ত্রে ছড়ানোর পরে। সাধারণ ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
সব যন্ত্রে একই password বা API key কোডে লেখেপ্রতিটি যন্ত্রের আলাদা key বা certificate চাই; কোডে খুঁজে দেখুন কোনো গোপন মান আছে কি না
OTA-তে সরাসরি চলমান firmware-এর ওপর লেখে, কোনো fallback নেইA/B slot আর confirm-এর নিয়ম আছে কি না; download-এর মাঝে বিদ্যুৎ গেলে কী হয়, ধাপে ধাপে লিখে দেখা
শুধু hash মেলায়, signature নেই; TLS ছাড়া image নামায়Manifest-এ signature আর যাচাইয়ের public key কোথায়, তা খোঁজা (পর্ব ৭৭)
Keep-alive বা heartbeat-এর সময় আন্দাজে বলে, offline ধরার দেরি হিসাব করে নাMQTT 3.1.1-এর 1.5 গুণ নিয়ম আর monitor-এর বিরতি দিয়ে সর্বোচ্চ দেরি নিজে গোনা; local broker-এ চালিয়ে মাপা
Telemetry-র সারাংশে শুধু গড় রাখে, duplicate বাদ দেয় নাmin/max আছে কি না, আর (dev, seq)-এ primary key বা অন্য deduplication আছে কি না
Update সব যন্ত্রে একসাথে পাঠায়ধাপ, থামার সীমা আর প্রতিটি hardware revision-এর প্রতিনিধিত্ব আছে কি না

প্রয়োজন, সীমা আর যাচাইয়ের শর্ত প্রথমেই দিন:

আমি দুশোটি ওজনের scale-এর একটি বহরের device management নকশা করছি। প্রতিটি scale একটি Cortex-M3 MCU, 128 KiB flash, MQTT 3.1.1 দিয়ে একটি broker-এ যুক্ত, আর ৪০টি পুরোনো hardware revision-এর। ১. প্রতিটি যন্ত্রের আলাদা পরিচয়সহ provisioning-এর ধাপগুলো লেখো; কোনো key বা password কোডে লিখবে না, নকল মান ব্যবহার করবে। ২. Keep-alive, Last Will আর application heartbeat-এর মান দাও, আর একটি যন্ত্রের বিদ্যুৎ গেলে সর্বোচ্চ কত সেকেন্ডে alert আসবে, হিসাব করে দেখাও। ৩. A/B slot-এ OTA-র পুরো ধাপ লেখো: manifest-এ কী থাকবে, signature কোথায় যাচাই হবে, confirm আর rollback কখন। ৪. ধাপে ধাপে rollout-এর পরিকল্পনা দাও: প্রতিটি ধাপের আকার, থামার সীমা, আর পুরোনো revision কীভাবে প্রথম ধাপেই পরীক্ষা হবে। ৫. যে তথ্য কোনো নির্দিষ্ট cloud সেবা বা bootloader-এর নথি থেকে যাচাই করতে হবে, আলাদা করে চিহ্নিত করো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১২০১৬ সালের Mirai botnet-কে প্রায়ই IoT নিরাপত্তার মোড় ঘোরানো ঘটনা বলা হয়। সেই ঘটনা provisioning আর “প্রতিটি যন্ত্রের আলাদা পরিচয়” নীতি নিয়ে কী শেখায়?

Mirai নামের malware ২০১৬ সালে লাখো IoT যন্ত্র, মূলত IP ক্যামেরা আর home router, দখল করে একটি botnet বানায় বলে ব্যাপকভাবে প্রকাশিত। সেপ্টেম্বর-অক্টোবর ২০১৬-এ এই botnet থেকে কয়েকটি খুব বড় DDoS আক্রমণ হয়, যার একটি একটি বড় DNS সেবাদাতাকে আঘাত করে আর বহু জনপ্রিয় website কিছু সময়ের জন্য পৌঁছানো কঠিন হয়ে যায়। পরে একটি গবেষক দলের বিশ্লেষণ ২০১৭ সালে USENIX Security সম্মেলনে “Understanding the Mirai Botnet” নামে প্রকাশিত হয়।

আক্রমণের কৌশল ছিল অবাক করার মতো সরল। Mirai-এর কোডে কয়েক ডজন কারখানার default username আর password-এর একটি তালিকা ছিল। সে ইন্টারনেটে খোলা Telnet port খুঁজত আর এই তালিকা দিয়ে login-এর চেষ্টা করত। কোনো জটিল দুর্বলতা লাগেনি: লাখো যন্ত্র একই মডেলের, একই কারখানার password নিয়ে চলছিল, আর অনেক মালিক জানতেনই না যে password বদলানো যায়।

এই পর্বের ভাষায় এটি একটি provisioning-এর ব্যর্থতা। প্রতিটি যন্ত্রের পরিচয় আলাদা ছিল না, তাই একটি যন্ত্রের password জানা মানে সব যন্ত্রের password জানা। আর যন্ত্রগুলো বাইরে থেকে login নেওয়ার জন্য খোলা ছিল, যেখানে বাজারঘরের scale শুধু বাইরের দিকে broker-এ সংযোগ খোলে আর তার কোনো খোলা port নেই। এই ঘটনার পরে বিভিন্ন দেশে IoT যন্ত্রের নিয়মে “সর্বজনীন default password নিষেধ”-এর মতো শর্ত আসতে থাকে; যেমন যুক্তরাজ্যের consumer IoT নিরাপত্তা আইন আর ETSI EN 303 645 মানদণ্ডে এই নীতি আছে বলে জানা যায়।

বাজারঘরের নকশায় শিক্ষাটি সরাসরি বসে: প্রতিটি scale-এর key আলাদা, কারখানায় বসানো, তারে যায় না; registry-তে প্রতিটির অবস্থা আলাদা; একটি scale চুরি হলে শুধু সেটির key বাতিল করা যায়।

মূল উপলব্ধি: Mirai দেখিয়েছে বহরের নিরাপত্তা তার সবচেয়ে দুর্বল, সবচেয়ে একরকম অংশের সমান। প্রতিটি যন্ত্রের আলাদা পরিচয় আর কোনো খোলা login না রাখা provisioning-এর প্রথম শর্ত।

প্র ০২একটি যন্ত্র সত্যিই মারা গেছে, নাকি শুধু ধীর বা পথ সাময়িক বন্ধ, দূর থেকে কি নিশ্চিতভাবে বলা যায়? Keep-alive আর heartbeat-এর timeout বাছাইয়ে এই প্রশ্ন কেন কেন্দ্রীয়?

Distributed system-এর তত্ত্বে এই প্রশ্নের উত্তর হতাশাজনক: সাধারণভাবে না। ১৯৮৫ সালে Fischer, Lynch আর Paterson-এর বিখ্যাত ফল (যা FLP impossibility নামে পরিচিত) দেখায়, যেখানে বার্তা কত দেরিতে পৌঁছাবে তার কোনো সীমা নেই, সেখানে একটিমাত্র প্রক্রিয়াও থেমে যেতে পারলে সব ক্ষেত্রে একমত হওয়ার নিশ্চিত পদ্ধতি নেই। এর মূলে আছে ঠিক এই সমস্যা: একটি ধীর প্রক্রিয়া আর একটি মৃত প্রক্রিয়াকে বাইরে থেকে আলাদা করা যায় না। পরে Chandra আর Toueg (১৯৯৬) “failure detector” ধারণা দিয়ে দেখান, অনিখুঁত কিন্তু নির্দিষ্ট ধর্মের detector থাকলে কী কী সম্ভব।

বাস্তবে তাই প্রতিটি timeout একটি বাজি। ছোট timeout মানে দ্রুত alert, কিন্তু একটু ধীর network-এ ভুল alert আসে। বড় timeout মানে কম ভুল alert, কিন্তু সত্যিকারের বিপদ দেরিতে ধরা পড়ে। এই পর্বের heartbeat-এর কোডে “পরপর ৩টি না এলে” নিয়মটি একটি হারানো বার্তায় চুপ থাকে (scale-2), কিন্তু cold room-এর সত্যিকারের নীরবতা ধরতে 210 s লেগেছে। বাজারঘরে এই 210 s মেনে নেওয়া যায়, কারণ alarm নিজেই device-এ বাজে; শুধু দূরের মানুষ দেরিতে জানেন।

কিছু ব্যবস্থা হ্যাঁ-না-এর বদলে সন্দেহের মাত্রা হিসাব করে। ২০০৪ সালে Hayashibara ও সহকর্মীদের “φ accrual failure detector” আগের heartbeat-গুলোর আসার সময়ের বণ্টন থেকে বলে, এখনকার নীরবতা কতটা অস্বাভাবিক; পরে কিছু বড় database এই ধারণা ব্যবহার করেছে বলে জানা যায়। IoT-তে সাধারণত সরল নিয়মই যথেষ্ট, কিন্তু একটি শিক্ষা নেওয়া জরুরি: “offline” মানে “আমরা দেখতে পাচ্ছি না”, “যন্ত্র নষ্ট” নয়। Dashboard-এ তাই লেখা উচিত “শেষ খবর 210 s আগে”, রায় নয়।

মূল উপলব্ধি: দূর থেকে ধীর আর মৃত যন্ত্রকে নিশ্চিতভাবে আলাদা করা যায় না। প্রতিটি timeout দ্রুততা আর ভুল alert-এর মধ্যে একটি সচেতন আপস, আর alert-এর ভাষা সেই অনিশ্চয়তা স্বীকার করবে।

প্র ০৩Time-series database-এ পুরোনো data সংক্ষেপ করার ধারণা কোথা থেকে এল, আর সংক্ষেপ করতে গিয়ে কোন তথ্য হারানো সবচেয়ে বিপজ্জনক?

Network-এর যন্ত্রপাতি monitor করার জগতে ধারণাটি অনেক পুরোনো। ১৯৯০-এর দশকে Tobias Oetiker-এর MRTG (Multi Router Traffic Grapher) router-এর traffic-এর graph আঁকত, আর ১৯৯৯ সালের দিকে তিনি RRDtool প্রকাশ করেন। RRD মানে round-robin database: একটি নির্দিষ্ট আকারের file, যার ভেতরে কয়েকটি “archive”, প্রতিটি আলাদা সূক্ষ্মতায়; যেমন শেষ এক দিনের প্রতি পাঁচ মিনিটের মান, শেষ এক মাসের প্রতি ঘণ্টার মান। নতুন মান এলে পুরোনোটি চক্রাকারে মুছে যায়, তাই file কখনো বাড়ে না। মান সংক্ষেপের নিয়মকে RRDtool বলে consolidation function, আর গড়ের পাশাপাশি MIN, MAX আর LAST রাখার ব্যবস্থাও ছিল।

এই শেষ কথাটিই মূল শিক্ষা। এই পর্বের সত্যিকারের cold room-এর ডেটায় প্রথম ১০ সেকেন্ডের গড় ঠিক 7.00 °C, যা সীমার ভেতরে; অথচ চারটি reading 8.00 °C-এর ওপরে আর সর্বোচ্চ 9.50 °C. শুধু গড় রাখা database এক মাস পরে বলবে “সব ঠিক ছিল”, অথচ ওষুধ বা মাছের মতো পণ্যের জন্য ওই কয়েক মিনিটই আসল প্রশ্ন। Signal processing-এর ভাষায়, গড় একটি low-pass filter (পর্ব ৬৮): ধীর পরিবর্তন রাখে, দ্রুত চূড়া মুছে দেয়।

তাই নিয়ম: যে প্রশ্নের উত্তর ভবিষ্যতে চাইবেন, সারাংশে তার উপকরণ রাখুন। সীমা পার হয়েছে কি না জানতে সর্বোচ্চ আর সর্বনিম্ন; কতক্ষণ পার ছিল জানতে সীমার বাইরের reading-এর সংখ্যা; আর ঘটনার সঠিক সময় দরকার হলে alarm-এর বার্তা আলাদা করে, সংক্ষেপ ছাড়া, রাখা। কতদিন কাঁচা মান রাখবেন, তা ঠিক করে storage-এর খরচ, আইনি বা ব্যবসার নিয়ম, আর কত পুরোনো ঘটনা তদন্ত করতে হতে পারে।

মূল উপলব্ধি: Downsampling-এর ধারণা RRDtool-এর মতো পুরোনো monitoring যন্ত্র থেকে এসেছে। গড় চূড়া লুকায়; তাই সারাংশে min, max আর সীমা পারের সংখ্যা রাখতে হয়, আর জরুরি ঘটনা আলাদা রাখতে হয়।

প্র ০৪দুটি slot রেখে update করার ধারণা মহাকাশযান থেকে মোবাইল ফোন পর্যন্ত ছড়িয়েছে। Flash-এর জায়গা দ্বিগুণ খরচ করে কেন এই নকশা টিকে আছে, আর এর বিকল্প কী?

দূরের, হাতের নাগালের বাইরের যন্ত্রে software বদলানোর সবচেয়ে চরম উদাহরণ মহাকাশযান। NASA-র Voyager যান দুটি ১৯৭৭ সালে উৎক্ষেপণের পরে কয়েক দশক ধরে পৃথিবী থেকে পাঠানো নির্দেশে তাদের কম্পিউটারের software বদলানো হয়েছে বলে NASA জানিয়েছে; সেখানে একটি ভুল update মানে চিরতরে হারানো যান। এমন জায়গায় প্রকৌশলীরা সাধারণত একটি পরিচিত-ভালো অবস্থায় ফেরার পথ সবসময় খোলা রাখেন।

মোবাইল ফোনে একই নীতি বড় মাপে এসেছে। Android 7.0 (২০১৬) থেকে “A/B (seamless) system update” চালু হয় বলে Android-এর নথিতে বলা আছে: ফোন চলার সময়ই অন্য slot-এ নতুন system লেখা হয়, পরের restart-এ slot বদলায়, আর নতুনটি boot না হলে পুরোনোটিতে ফেরা যায়। Microcontroller-এর জগতে MCUboot-এর মতো খোলা bootloader একই ধারণা ছোট মাপে দেয়: নতুন image-কে “test” হিসেবে চালানো, আর confirm না হলে পরের reset-এ ফেরা, তাদের নথিতে এর বর্ণনা আছে।

জায়গার খরচ সত্যি: একটি 128 KiB flash-এর MCU-তে দুটি পূর্ণ slot মানে firmware-এর জন্য 64 KiB-এর কম। বিকল্প কয়েকটি। এক, একটি ছোট নিরাপদ “recovery” image আর একটি বড় প্রধান slot: প্রধানটি ভাঙলে recovery শুধু নতুন image নামাতে পারে। দুই, বাইরের SPI flash-এ নতুন image নামানো, তারপর bootloader তা ভেতরের flash-এ কপি করে; কপির মাঝে বিদ্যুৎ গেলে আবার শুরু করার ব্যবস্থা লাগে। তিন, শুধু পরিবর্তনটুকু পাঠানো (delta update), যা radio-র শক্তি আর data বাঁচায় কিন্তু নকশা জটিল করে। প্রতিটির মূল প্রশ্ন একই: যেকোনো মুহূর্তে বিদ্যুৎ গেলে যন্ত্র কি এমন একটি অবস্থায় থাকবে যেখান থেকে নিজে চালু হতে পারে?

মূল উপলব্ধি: A/B নকশা flash-এর জায়গা দিয়ে নিশ্চয়তা কেনে: সবসময় একটি পরিচিত-ভালো firmware অক্ষত। বিকল্পগুলো জায়গা বাঁচায়, কিন্তু প্রতিটিকে একই প্রশ্নের উত্তর দিতে হয়: মাঝপথে বিদ্যুৎ গেলে কী হবে?

প্র ০৫“Canary release” নামটি কয়লাখনির পাখি থেকে এসেছে। IoT-তে ছোট একটি canary ধাপ কোন কোন ভুল ধরতে পারে না, আর rollout-এর নকশা তা কীভাবে সামলায়?

খনির শ্রমিকেরা একসময় খাঁচায় canary পাখি নিয়ে খনিতে নামতেন। কার্বন মনোক্সাইডের মতো বিষাক্ত গ্যাসে ছোট পাখি মানুষের আগে অসুস্থ হয়, তাই পাখির অবস্থা ছিল সতর্কসংকেত। যুক্তরাজ্যের খনিতে এই প্রথা ১৯৮৬ সাল পর্যন্ত চলেছিল বলে সাধারণত উল্লেখ করা হয়, তারপর electronic gas detector তার জায়গা নেয়। Software-এ নামটি এসেছে একই যুক্তিতে: অল্প কিছু ব্যবহারকারী বা যন্ত্র আগে নতুন version পায়, সমস্যা হলে তারাই প্রথম সংকেত দেয়।

কিন্তু canary শুধু সেই বিপদ ধরে, যা তার গায়ে লাগে। এই পর্বের rollout-এর কোডে প্রথম ধাপের দুটি scale-ই rev A ছিল, তাই rev B-র ভুল প্রথম ধাপে ধরা পড়েনি; দ্বিতীয় ধাপে ধরা পড়েছে। IoT বহরে এমন “আড়াল” অনেক: পুরোনো hardware revision, আলাদা sensor সরবরাহকারী, দুর্বল signal-এর জায়গা, বেশি তাপমাত্রার ঘর, বা মাসে একবার ঘটে এমন কাজ (মাস শেষের হিসাব)। কিছু ভুল আবার সময়ের সঙ্গে আসে, যেমন memory ধীরে ধীরে ফুরিয়ে যাওয়া, যা কয়েক ঘণ্টার canary-তে দেখা যায় না।

নকশায় তিনটি উত্তর আছে। এক, canary এলোমেলো না রেখে স্তরভিত্তিক বাছাই: প্রতিটি hardware revision আর প্রতিটি ধরনের পরিবেশ থেকে অন্তত একটি। দুই, প্রতিটি ধাপে যথেষ্ট সময় অপেক্ষা, আর health check-এ শুধু “boot হলো” নয়, আসল কাজের মাপ: sensor-এর মান যুক্তিসংগত কি না, heartbeat নিয়মিত কি না, reset-এর সংখ্যা বেড়েছে কি না। তিন, থামার সীমা স্পষ্ট লেখা আর স্বয়ংক্রিয়, যাতে রাত দুটোয় কারো সিদ্ধান্তের অপেক্ষা না লাগে। আর সবশেষে, যন্ত্রের ভেতরের rollback-ই শেষ রক্ষা: canary যা ধরতে পারেনি, তার ক্ষতিও যেন প্রতিটি যন্ত্র নিজে সামলাতে পারে।

মূল উপলব্ধি: Canary শুধু তার নিজের ধরনের বিপদ ধরে। তাই প্রথম ধাপ বহরের প্রতিটি ধরনের প্রতিনিধি দিয়ে গড়তে হয়, health check আসল কাজ মাপে, থামার নিয়ম স্বয়ংক্রিয়, আর শেষ ভরসা যন্ত্রের নিজের rollback.

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। উত্তরের প্রতিটি সংখ্যা Python-এ চালিয়ে মেলানো।

  1. নকশা ও বাস্তবায়ন — A/B bootloader-এর সিদ্ধান্ত: একটি bootloader-এর জন্য দুটি Python ফাংশন লিখুন। অবস্থা একটি dict: active (চলমান slot), pending (নতুন image-এর slot বা None), tries. boot(st) প্রতিটি reset-এ ডাকা হয় আর কোন slot চলবে তা ফেরত দেয়: pending থাকলে প্রথমবার সেটি পরীক্ষামূলক চালাবে, আর confirm ছাড়াই আবার reset হলে pending বাতিল করে active-এ ফিরবে। confirm(st) নতুন firmware health check-এর পরে ডাকে। তিনটি ঘটনায় পরীক্ষা করুন: ভালো image, crash করা image, আর download-এর মাঝে বিদ্যুৎ যাওয়া।
    def boot(st):
        """Called by the bootloader on every reset. Returns the slot to run."""
        if st["pending"] is not None:
            if st["tries"] == 0:              # first boot of the new image: test it
                st["tries"] = 1
                return st["pending"]
            st["pending"] = None              # it did not confirm itself: revert
            st["tries"] = 0
        return st["active"]
    
    def confirm(st):
        """Called by the new firmware after its health check passed."""
        if st["pending"] is not None:
            st["active"], st["pending"], st["tries"] = st["pending"], None, 0

    আমার lab-এ চালানো ফল (সত্যিকারের run, Python 3.13.5): ভালো image-এ প্রথম boot slot B, confirm-এর পরে reset-এও B, অবস্থা {'active': 'B', 'pending': None, 'tries': 0}. Crash করা image-এ প্রথম boot B, তারপর watchdog-এর reset-এ A, পরের reset-এও A, pending মুছে গেছে। Download-এর মাঝে বিদ্যুৎ গেলে pending তখনো বসানো হয়নি, তাই boot A. মূল নিয়মটি হলো ক্রম: image পুরো নামানো আর যাচাই (আকার, hash, signature) শেষ হলে তবেই pending লেখা। আসল bootloader-এ এই অবস্থা flash-এর একটি আলাদা জায়গায় থাকে, আর লেখাটি এমনভাবে করা হয় যাতে মাঝপথে বিদ্যুৎ গেলেও আধা-লেখা অবস্থা না থাকে।

  2. ভুল খুঁজুন — একটি fleet-নকশার নোট: “সব scale-এর firmware-এ একই MQTT password থাকবে। Keep-alive 0 রাখা হবে, যাতে PINGREQ-এ শক্তি খরচ না হয়; offline ধরবে Last Will. পরিকল্পিত restart-এ scale DISCONNECT পাঠাবে, Last Will dashboard-কে offline দেখাবে। Telemetry-র প্রতি ঘণ্টার সারাংশে শুধু গড় থাকবে। নতুন firmware রাতে সব scale-এ একসাথে যাবে, চলমান firmware-এর ওপরে লেখা হবে, আর hash মিললেই চালানো হবে।” অন্তত পাঁচটি ভুল দেখান।

    ১, একই password: একটি scale খুলে flash পড়লেই পুরো বহর খোলা, আর বদলাতে সব firmware বদলাতে হবে; প্রতিটির আলাদা key বা certificate চাই। ২, keep-alive 0: MQTT-তে 0 মানে keep-alive-এর কৌশল বন্ধ; বিদ্যুৎ চলে গেলে TCP বন্ধের খবর আসে না, তাই broker কখনো সংযোগ ভাঙবে না আর Last Will কখনো প্রকাশ হবে না। ৩, DISCONNECT-এ Last Will: নিয়মমতো DISCONNECT-এ Last Will মুছে যায়; scale-কে নিজে offline লিখে তারপর DISCONNECT পাঠাতে হবে (lab-এর ঘটনা C). ৪, শুধু গড়: চূড়া লুকায়; একই ধরনের ডেটায় গড় 7.00 °C অথচ সর্বোচ্চ 9.50 °C ছিল। Min আর max রাখতে হবে। ৫, সব একসাথে: একটি ভুলে সব scale একসাথে; ধাপে ধাপে, থামার সীমাসহ। ৬, চলমান firmware-এর ওপরে লেখা: মাঝপথে বিদ্যুৎ গেলে scale অচল; A/B slot আর confirm চাই। ৭, শুধু hash: hash বলে image বদলায়নি, কে বানিয়েছে তা বলে না; signature লাগবে (পর্ব ৭৭).

  3. হিসাব — offline ধরার দেরি আর storage: (ক) একটি scale-এর MQTT keep-alive 60 s. তার বিদ্যুৎ চলে গেলে broker সর্বোচ্চ কত সময় পরে সংযোগ ভাঙবে? (খ) Application heartbeat প্রতি 60 s, নিয়ম “চুপ 180 s-এর বেশি হলে offline”, monitor প্রতি 30 s-এ দেখে (0, 30, 60 … s-এ)। শেষ heartbeat 0 s-এ এলে alert কখন? (গ) ৫০টি ঠান্ডা ঘর, প্রতিটি প্রতি 10 s-এ একটি সারি, প্রতি সারি 40 byte. এক বছরে কত সারি আর কত GiB? প্রতি 10 মিনিটের একটি সারাংশ-সারিতে নামালে কত সারি, কত গুণ কম?

    (ক) 1.5 × 60 = 90 s কোনো packet না পেলে broker সংযোগ ভাঙে আর Last Will প্রকাশ করে (MQTT 3.1.1-এর অংশ 3.1.2.10 অনুযায়ী)। Lab-এ keep-alive 2 s দিয়ে একই নিয়মে 3.0 s মাপা গেছে। (খ) 180 s-এ চুপ ঠিক 180 s, “বেশি” নয়; পরের দেখা 210 s-এ, তাই alert 210 s-এ। সাধারণ সূত্র: সর্বোচ্চ দেরি ≈ সীমা + monitor-এর বিরতি। (গ) এক বছর = 365 × 24 × 3600 = 31536000 s; প্রতি ঘরে 3153600 সারি, ৫০টিতে 157680000 সারি; × 40 byte = 6307200000 byte ≈ 5.87 GiB. 10 মিনিট = 600 s, তাই 50 × 31536000 / 600 = 2628000 সারি, ঠিক ৬০ গুণ কম, 40 byte করে ধরলে প্রায় 100.3 MiB. সংখ্যাগুলো আমার lab-এর Python-এ মেলানো (সত্যিকারের run). Database-এর index আর অন্য বাড়তি খরচ এখানে ধরা হয়নি; বাস্তবে জায়গা বেশি লাগে, আর সারাংশে min/max রাখলে প্রতি সারি একটু বড় হয়।

  4. আগে বলুন — একটি rollout-এর ফল: ৫০০টি যন্ত্রের একটি বহরে update চারটি ধাপে যাবে: 5, 25, 100, 370টি। নিয়ম: কোনো ধাপে ব্যর্থতা 2%-এর বেশি হলে থামা; ব্যর্থ যন্ত্র নিজে পুরোনো slot-এ ফেরে। ধাপগুলোতে ব্যর্থ হবে যথাক্রমে 0, 1, 6 আর 9টি। কোন ধাপের পরে rollout থামবে, তখন কয়টি যন্ত্র নতুন version-এ, কয়টি rollback করেছে, আর কয়টি update-ই পায়নি?

    ধাপ ১: 0 / 5 = 0%, এগোনো। ধাপ ২: 1 / 25 = 4%, যা 2%-এর বেশি: ধাপ ২-এর পরে থামবে. নতুন version-এ 5 + 24 = ২৯টি, rollback ১টি, update পায়নি 500 − 30 = ৪৭০টি. ধাপ ৩ আর ৪-এর ব্যর্থতার সংখ্যা কখনো দেখাই হয় না। আমার lab-এর Python-এ একই ফল (সত্যিকারের run). লক্ষ করুন, ধাপ ৩-এ 6 / 100 = 6% আর ধাপ ৪-এ 9 / 370 ≈ 2.4% হলেও, শতাংশের সীমা ছোট ধাপে খুব সংবেদনশীল: 25টিতে একটি ব্যর্থতাই 4%. অনেক নকশা তাই শতাংশের সঙ্গে ন্যূনতম সংখ্যার শর্তও রাখে, যেমন “অন্তত ২টি আর 2%-এর বেশি”.

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

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

ক্রমA/B slot-এ একটি নিরাপদ OTA update-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Cloud নতুন version-এর manifest প্রকাশ করে: আকার, SHA-256 আর signature
  2. যন্ত্র নতুন image টুকরো টুকরো করে অন্য slot-এ নামায়, চলমান firmware অক্ষত রেখে
  3. যন্ত্র আকার, hash আর signature মিলিয়ে image যাচাই করে
  4. Bootloader নতুন image পরীক্ষামূলকভাবে চালায়
  5. নতুন firmware health check পাস করে নিজেকে confirm করে, নয়তো পরের reset-এ পুরোনো slot
  6. যন্ত্র নিজের নতুন version cloud-এর registry-কে জানায়

একটি MQTT 3.1.1 client CONNECT-এ keep-alive 30 s বলেছে। তার বিদ্যুৎ চলে গেল, কোনো packet বা TCP বন্ধের খবর আর আসে না। Broker সর্বোচ্চ কত সময় পরে সংযোগ ভাঙবে আর Last Will প্রকাশ করবে?

  • 30 s
  • 60 s
  • 45 s
  • কখনো না, TCP নিজে বন্ধ না হলে

একটি MQTT client সংযোগের সময় status topic-এ offline Last Will দিয়ে রেখেছিল। নিচের কোন ঘটনায় broker সেই Last Will প্রকাশ করবে না?

  • যন্ত্রের বিদ্যুৎ চলে গেল, keep-alive-এর সময় পার হলো
  • যন্ত্র নিয়মমতো DISCONNECT পাঠিয়ে বিদায় নিল
  • যন্ত্রের program crash করল, OS TCP সংযোগ বন্ধ করল
  • Gateway-এর তার কেটে গেল আর broker-এর কাছে আর কিছু এল না

একটি IoT বহরের provisioning-এ প্রতিটি যন্ত্রের key আলাদা রাখার প্রধান কারণ কোনটি?

  • তাহলে TLS আর লাগে না
  • Provisioning দ্রুত হয়
  • Key ছোট হয়, flash-এ জায়গা বাঁচে
  • একটি যন্ত্রের key ফাঁস হলে বাকি বহর নিরাপদ থাকে আর শুধু সেটি বাতিল করা যায়

একটি MCU-র flash দুটি slot-এ ভাগ করা, A আর B. নতুন firmware slot B-তে নামানোর মাঝখানে বিদ্যুৎ চলে গেল। বিদ্যুৎ ফিরলে কী হওয়া উচিত?

  • Slot A-র পুরোনো firmware চলবে, update পরে আবার চেষ্টা হবে
  • Slot B-র আধা-নামানো firmware চলবে
  • যন্ত্র অচল হবে, হাতে করে programming লাগবে
  • Bootloader network থেকে পুরো image না আসা পর্যন্ত কিছুই চালাবে না

একটি ঠান্ডা ঘরের ১০টি reading (°C): 4.00, 4.00, 5.50, 5.50, 8.25, 9.00, 9.50, 9.50, 7.75, 7.00; সীমা 8.00 °C. এদের সারাংশ রাখতে চাইলে কোনটি সবচেয়ে কম তথ্য হারায়?

  • শুধু গড় (7.00)
  • শুধু শেষ মান (7.00)
  • গড়, সর্বনিম্ন, সর্বোচ্চ আর সীমা-পার reading-এর সংখ্যা
  • শুধু প্রথম মান (4.00)

২০০টি যন্ত্রে update-এর প্রথম ধাপে মাত্র ২টি যন্ত্র নেওয়া হলো, দুটিই নতুন hardware revision-এর, আর পাস করল। দ্বিতীয় ধাপে পুরোনো revision-এর একটি যন্ত্র ব্যর্থ হলো। এ থেকে সবচেয়ে ভালো শিক্ষা কোনটি?

  • Canary ধাপ অকাজের, সরাসরি সবগুলোতে পাঠানো ভালো
  • প্রথম ধাপে প্রতিটি hardware revision-এর প্রতিনিধি রাখা উচিত
  • ব্যর্থ যন্ত্রের rollback বন্ধ রাখা উচিত, যাতে সমস্যা স্পষ্ট দেখা যায়
  • থামার সীমা বাড়িয়ে 50% করা উচিত

একটি OTA manifest-এ image-এর SHA-256 আছে, signature নেই। যন্ত্র নামানো image-এর hash মিলিয়ে তবেই চালায়। এই নকশা কোন বিপদ ঠেকায় না?

  • পথে একটি bit উল্টে যাওয়া
  • Download-এর একটি টুকরো হারানো
  • ভুল করে অন্য মডেলের image পাঠানো
  • আক্রমণকারীর নিজের image আর তার hash-সহ নকল manifest

শব্দকোষ

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

মনে রাখুন

  1. জীবনচক্র: কারখানা → provisioning → active (telemetry, heartbeat, config) ⇄ OTA আর offline → decommission; প্রতিটি অবস্থায় cloud-এর একটি সেবা।
  2. Provisioning: প্রতিটি যন্ত্রের আলাদা key বা certificate; key তারে যায় না, nonce-এর ওপর HMAC বা signature দিয়ে প্রমাণ; registry-তে অবস্থা manufactured থেকে active.
  3. Telemetry: (dev, seq)-এ primary key দিলে duplicate নিজে বাদ; সারাংশে গড়ের পাশে min, max আর সীমা-পারের সংখ্যা, নইলে চূড়া হারায়।
  4. Offline ধরা: broker keep-alive × 1.5 পরে সংযোগ ভাঙে আর Last Will প্রকাশ করে; DISCONNECT-এ Last Will মোছে; heartbeat-এ সর্বোচ্চ দেরি = সীমা + monitor-এর বিরতি।
  5. OTA: A/B slot, আকার + SHA-256 + signature, পরীক্ষামূলক boot, confirm না হলে rollback; বহরে ধাপে ধাপে, প্রতিটি revision-এর canary আর স্বয়ংক্রিয় থামার সীমা।

পরের পর্বে: পর্ব ৭৬ (IoT security — ঝুঁকি, threat model আর নিরাপদ নকশার নিয়ম). এই পর্বের প্রতিটি অংশ, provisioning, নির্দেশ আর OTA, আক্রমণকারীর চোখে দেখা: কোথায় ঝুঁকি, কে আক্রমণ করতে পারে, আর বাজারঘরের নকশায় কোন নিয়ম তাদের ঠেকায়।

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

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