इस पेज का अनुवाद Cloud Translation API से किया गया है.

Docker में OpenThread का इस्तेमाल करके, Thread नेटवर्क को सिम्युलेट करना

1. परिचय

Google की ओर से रिलीज़ किया गया OpenThread, Thread नेटवर्किंग प्रोटोकॉल का ओपन सोर्स लागू किया गया है. Google Nest ने OpenThread लॉन्च किया है, ताकि Nest के प्रॉडक्ट में इस्तेमाल की जाने वाली टेक्नोलॉजी को डेवलपर के लिए बड़े पैमाने पर उपलब्ध कराया जा सके. इससे कनेक्टेड होम के लिए प्रॉडक्ट बनाने में तेज़ी लाने में मदद मिली है.

Thread की खास बातें, होम ऐप्लिकेशन के लिए आईपीवी6 आधारित भरोसेमंद, सुरक्षित, और कम पावर वाले वायरलेस डिवाइस-टू-डिवाइस कम्यूनिकेशन प्रोटोकॉल के बारे में बताती हैं. OpenThread ने सभी Thread नेटवर्किंग लेयर को लागू किया होता है, जिनमें आईपीवी6, 6LoWPAN, IEEE 802.15.4 के साथ-साथ MAC सिक्योरिटी, मेश लिंक इस्टैब्लिशमेंट, और मेश रूटिंग शामिल हैं.

यह कोडलैब आपको Docker का इस्तेमाल करके, एम्युलेट किए गए डिवाइसों पर Thread नेटवर्क को सिम्युलेट करने का तरीका बताएगा.

आप इन चीज़ों के बारे में जानेंगे

OpenThread: बिल्ड टूलचेन को सेट अप करने का तरीका
Thread नेटवर्क को सिम्युलेट करने का तरीका
थ्रेड नोड की पुष्टि करने का तरीका
OpenThread Deemon की मदद से, Thread नेटवर्क को मैनेज करने का तरीका

आपको इनकी ज़रूरत होगी

डॉकर
Linux, नेटवर्क रूटिंग की बुनियादी जानकारी

2. Docker सेट अप करें

इस कोडलैब को Linux, Mac OS X या Windows मशीन पर Docker का इस्तेमाल करने के लिए डिज़ाइन किया गया है. Linux सुझाया गया एनवायरमेंट है.

Docker इंस्टॉल करें

अपनी पसंद के ओएस पर Docker इंस्टॉल करें.

Docker इमेज खींचें

Docker इंस्टॉल होने के बाद, टर्मिनल विंडो खोलें और openthread/environment की Docker इमेज खींचें. इस इमेज में, पहले से तैयार OpenThread और OpenThread Deemon फ़ीचर हैं, जो कोडलैब के लिए इस इमेज का इस्तेमाल करने के लिए तैयार हैं.

$ docker pull openthread/environment:latest

ध्यान दें कि इसे पूरी तरह से डाउनलोड होने में कुछ मिनट लग सकते हैं.

टर्मिनल विंडो में, इमेज से Docker कंटेनर शुरू करें और इसके bash शेल से कनेक्ट करें:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

--rm विकल्प, कंटेनर से बाहर निकलने पर कंटेनर को मिटा देता है. अगर आपको कंटेनर मिटाना नहीं है, तो इस विकल्प का इस्तेमाल न करें.

इस कोडलैब के लिए ज़रूरी फ़्लैग नोट करें:

--sysctl net.ipv6.conf.all.disable_ipv6=0 — इससे कंटेनर में IPv6 चालू हो जाता है
--cap-add=net_admin — की मदद से, NET_Admin सुविधा चालू होती है. इसकी मदद से, नेटवर्क से जुड़ी कार्रवाइयां की जा सकती हैं, जैसे कि आईपी रूट जोड़ना

कंटेनर में पहुंचने के बाद, आपको इस तरह का प्रॉम्प्ट मिलेगा:

root@c0f3912a74ff:/#

ऊपर दिए गए उदाहरण में, c0f3912a74ff एक कंटेनर आईडी है. Docker कंटेनर के आपके इंस्टेंस का कंटेनर आईडी, इस कोडलैब के लिए प्रॉम्प्ट में दिखाए गए कंटेनर आईडी से अलग होगा.

Docker का इस्तेमाल करना

यह कोडलैब यह मानता है कि आपको Docker इस्तेमाल करने की बुनियादी बातें पता हैं. आपको कोडलैब के पूरे हिस्से के लिए Docker कंटेनर में रहना चाहिए.

3. Thread नेटवर्क को सिम्युलेट करें

इस कोडलैब के लिए उदाहरण के तौर पर इस्तेमाल किया जाने वाला ऐप्लिकेशन, छोटे से छोटे OpenThread ऐप्लिकेशन को दिखाता है. यह एक बेसिक कमांड-लाइन इंटरफ़ेस (सीएलआई) के ज़रिए, OpenThread कॉन्फ़िगरेशन और मैनेजमेंट इंटरफ़ेस को दिखाता है.

इस अभ्यास में, आपको उन आसान चरणों को पूरा करना होता है जो एम्युलेट किए गए किसी Thread डिवाइस को, एम्युलेट किए गए किसी अन्य Thread डिवाइस पर पिंग करने के लिए ज़रूरी होते हैं.

यहां दिए गए डायग्राम में Thread नेटवर्क की बुनियादी टोपोलॉजी के बारे में बताया गया है. इस अभ्यास के लिए, हम हरे रंग के सर्कल में मौजूद दो नोड को एम्युलेट कर देंगे: Thread Leader और Thread राऊटर के बीच एक कनेक्शन.

नेटवर्क बनाना

1. नोड 1 शुरू करें

अगर आपने पहले ऐसा नहीं किया है, तो टर्मिनल विंडो में जाकर Docker कंटेनर शुरू करें और इसके bash शेल से कनेक्ट करें:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Docker कंटेनर में, ot-cli-ftd बाइनरी का इस्तेमाल करके, एम्युलेट किए गए Thread डिवाइस के लिए सीएलआई प्रोसेस को शुरू करें.

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

ध्यान दें: अगर इस निर्देश को चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.

यह बाइनरी एक OpenThread डिवाइस लागू करती है. आईईईई 802.15.4 रेडियो ड्राइवर को यूडीपी के ऊपर लागू किया जाता है (आईईई 802.15.4 फ़्रेम यूडीपी पेलोड में पास किए जाते हैं).

1 का आर्ग्युमेंट ऐसा फ़ाइल डिस्क्रिप्टर है जो "फ़ैक्ट्री के तौर पर असाइन किए गए" के सबसे कम अहम बिट के बारे में बताता है एम्युलेट किए गए डिवाइस के लिए आईईईई ईयूआई-64. इस वैल्यू का इस्तेमाल तब भी किया जाता है, जब आईईईई 802.15.4 रेडियो एम्युलेशन (पोर्ट = 9000 + फ़ाइल डिस्क्रिप्टर) के लिए यूडीपी पोर्ट से जोड़ा जाता है. इस कोडलैब (कोड बनाना सीखना) में, एम्युलेट किए गए Thread डिवाइस का हर इंस्टेंस अलग-अलग फ़ाइल डिस्क्रिप्टर का इस्तेमाल करेगा.

ध्यान दें: किसी एम्युलेट किए गए डिवाइस की प्रोसेस तैयार करते समय, इस कोडलैब (कोड बनाना सीखना) में बताए गए तरीके से, सिर्फ़ 1 या उससे बड़े साइज़ के फ़ाइल डिस्क्रिप्टर का इस्तेमाल करें. 0 का फ़ाइल डिस्क्रिप्टर दूसरे इस्तेमाल के लिए रिज़र्व है.

एक नया ऑपरेशनल डेटासेट बनाएं और उसे ऐक्टिव डेटासेट के तौर पर सेट करें. ऑपरेशनल डेटासेट उस Thread नेटवर्क का कॉन्फ़िगरेशन है, जिसे आप बना रहे हैं.

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 20
Channel Mask: 07fff800
Ext PAN ID: d6263b6d857647da
Mesh Local Prefix: fd61:2344:9a52:ede0/64
Network Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

IPv6 इंटरफ़ेस खोलें:

> ifconfig up
Done

Thread प्रोटोकॉल पर कार्रवाई शुरू करें:

> thread start
Done

कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस Thread लीडर बन गया है. लीडर वह डिवाइस है जो राऊटर आईडी के असाइनमेंट को मैनेज करने का काम करता है.

> state
leader
Done

नोड 1 के Thread इंटरफ़ेस को असाइन किए गए IPv6 पते देखें (आपका आउटपुट अलग होगा):

> ipaddr
fd61:2344:9a52:ede0:0:ff:fe00:fc00
fd61:2344:9a52:ede0:0:ff:fe00:5000
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
fe80:0:0:0:94da:92ea:1353:4f3b
Done

कुछ खास तरह के आईपीवी6 पते पर ध्यान दें:

fd से शुरू होता है = मेश-लोकल
fe80 से शुरू होता है = link-local

मेश-स्थानीय पते के टाइप को आगे भी कैटगरी में बांटा गया है:

इसमें ff:fe00 = राऊटर लोकेटर (आरएलओसी) शामिल है
इसमें ff:fe00 = एंडपॉइंट आइडेंटिफ़ायर (ईआईडी) शामिल नहीं है

अपने कंसोल आउटपुट में ईआईडी की पहचान करें. इसे बाद में इस्तेमाल करने के लिए नोट करें. ऊपर दिए गए सैंपल आउटपुट में, ईआईडी यह है:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. नोड 2 शुरू करें

नोड 2 के लिए इस्तेमाल करने के लिए, नया टर्मिनल खोलें और मौजूदा समय में चल रहे Docker कंटेनर में bash शेल एक्ज़ीक्यूट करें.

$ docker exec -it codelab_otsim_ctnr bash

इस नए bash प्रॉम्प्ट पर, 2 आर्ग्युमेंट के साथ सीएलआई प्रोसेस को शुरू करें. यह आपका दूसरा एम्युलेट किया गया Thread डिवाइस है:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2

नोड 1 के ऑपरेशनल डेटासेट के समान मानों का इस्तेमाल करके Thread नेटवर्क कुंजी और पैन आईडी को कॉन्फ़िगर करें:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

IPv6 इंटरफ़ेस खोलें:

> ifconfig up
Done

Thread प्रोटोकॉल पर कार्रवाई शुरू करें:

> thread start
Done

डिवाइस खुद ही चाइल्ड के तौर पर शुरू हो जाएगा. Thread चाइल्ड, किसी एंड डिवाइस की तरह होता है. यह ऐसा Thread डिवाइस है जो सिर्फ़ माता-पिता के डिवाइस से यूनिकास्ट ट्रैफ़िक को भेजता और पाता है.

> state
child
Done

दो मिनट के अंदर, child से router पर स्विच किया जाएगा. Thread राऊटर की मदद से, Thread डिवाइसों के बीच ट्रैफ़िक को रूट किया जा सकता है. इसे अभिभावक भी कहा जाता है.

> state
router
Done

नेटवर्क की पुष्टि करें

राऊटर टेबल पर जाकर, मेश नेटवर्क की पुष्टि करने का आसान तरीका है.

1. इंटरनेट कनेक्शन की जांच करें

नोड 2 पर, RLOC16 पाएं. RLOC16, डिवाइस के RLOC IPv6 पते के आखिरी 16 बिट होते हैं.

> rloc16
5800
Done

नोड 1 पर, Node 2 के RLOC16 के लिए राऊटर टेबल देखें. पक्का करें कि नोड 2 को पहले राऊटर की स्थिति पर स्विच कर दिया गया हो.

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In  | LQ Out  | Age | Extended MAC   |
+----+--------+----------+-----------+--------+-------+---+--------------------+
| 20 | 0x5000 |       63 |         0 |      0 |     0 |   0 | 96da92ea13534f3b |
| 22 | 0x5800 |       63 |         0 |      3 |     3 |  23 | 5a4eb647eb6bc66c |

नोड 2 के 0x5800 का RLOC से पता चलता है कि वह मेश से कनेक्ट है या नहीं.

2. नोड 2 से पिंग नोड 1

एम्युलेट किए गए दो Thread डिवाइसों के बीच कनेक्टिविटी की पुष्टि करें. नोड 2 में, ping को नोड 1 को असाइन किया गया ईआईडी:

> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
> 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms

> सीएलआई प्रॉम्प्ट पर वापस जाने के लिए, enter दबाएं.

नेटवर्क की जांच करें

अब जबकि एम्युलेट किए गए दो Thread डिवाइसों के बीच सही तरीके से पिंग किया जा सकता है, तो ऑफ़लाइन मोड में एक नोड को निकालकर मेश नेटवर्क की जांच करें.

नोड 1 पर वापस जाएं और Thread को बंद करें:

> thread stop
Done

नोड 2 पर स्विच करें और स्टेटस देखें. दो मिनट में, नोड 2 यह पता लगा लेता है कि लीडर (नोड 1) ऑफ़लाइन है और आपको नोड 2 का ट्रांज़िशन नेटवर्क के leader के तौर पर दिखेगा:

> state
router
Done
...
> state
leader
Done

पुष्टि करने के बाद, Docker bash प्रॉम्प्ट पर वापस जाने से पहले, Thread को बंद करें और नोड 2 को फ़ैक्ट्री रीसेट करें. फ़ैक्ट्री रीसेट इसलिए किया जाता है, ताकि यह पक्का किया जा सके कि इस अभ्यास में हमने जिन Thread नेटवर्क के क्रेडेंशियल इस्तेमाल किए हैं वे अगली कसरत पर न जाएं.

> thread stop
Done
> factoryreset
>
> exit
root@c0f3912a74ff:/#

factoryreset निर्देश के बाद, > प्रॉम्प्ट को वापस लाने के लिए, आपको कुछ बार enter दबाना पड़ सकता है. Docker कंटेनर से बाहर न निकलें.

फ़ैक्ट्री रीसेट करें और नोड 1 से बाहर निकलें:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

सभी उपलब्ध सीएलआई निर्देशों के बारे में जानने के लिए, OpenThread CLI रेफ़रंस पर जाएं.

4. कमीशन की मदद से नोड की पुष्टि करें

पिछली कसरत में, आपने दो सिम्युलेटेड डिवाइसों और पुष्टि किए गए कनेक्टिविटी के साथ Thread नेटवर्क सेट अप किया था. हालांकि, इससे सिर्फ़ बिना पुष्टि वाले IPv6 लिंक-लोकल ट्रैफ़िक को एक डिवाइस से दूसरे डिवाइस पर जाने में मदद मिलती है. ग्लोबल आईपीवी6 ट्रैफ़िक को उनके बीच (और Thread बॉर्डर राऊटर के ज़रिए इंटरनेट) को रूट करने के लिए, नोड की पुष्टि की जानी चाहिए.

पुष्टि करने के लिए, एक डिवाइस को कमिश्नर के तौर पर काम करना होगा. नए Thread डिवाइसों के लिए, फ़िलहाल कमिश्नर को ऑथेंटिकेशन सर्वर (पुष्टि करने वाला) के तौर पर चुना गया है. साथ ही, यह डिवाइसों को नेटवर्क में शामिल होने के लिए ज़रूरी नेटवर्क क्रेडेंशियल देने का अधिकार देता है.

इस अभ्यास में, हम पहले की तरह ही टू-नोड टोपोलॉजी का इस्तेमाल करेंगे. पुष्टि करने के लिए, थ्रेड लीडर, कमिश्नर और थ्रेड राऊटर को जॉइनर के तौर पर काम करेगा.

डॉकर

बची हुई एक्सरसाइज़ में हर नोड (टर्मिनल विंडो) के लिए, पक्का करें कि OpenThread बिल्ड के साथ Docker कंटेनर चलाया जा रहा हो. पिछली एक्सरसाइज़ के बाद जारी रखने पर, आपके पास उसी Docker कंटेनर में पहले से खुले हुए दो bash प्रॉम्प्ट होने चाहिए. अगर ऐसा नहीं है, तो Docker समस्या का हल वाला तरीका देखें या सिम्युलेट ए Thread नेटवर्क एक्सरसाइज़ को फिर से आज़माएं.

1. नेटवर्क बनाएं

नोड 1 में, सीएलआई प्रोसेस को शुरू करें:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

एक नया ऑपरेशनल डेटासेट बनाएं, उसे ऐक्टिव डेटासेट के तौर पर तय करें, और Thread को शुरू करें:

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 12
Channel Mask: 07fff800
Ext PAN ID: e68d05794bf13052
Mesh Local Prefix: fd7d:ddf7:877b:8756/64
Network Key: a77fe1d03b0e8028a4e13213de38080e
Network Name: OpenThread-8f37
PAN ID: 0x8f37
PSKc: f9debbc1532487984b17f92cd55b21fc
Security Policy: 0, onrcb
Done

इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

IPv6 इंटरफ़ेस खोलें:

> ifconfig up
Done

Thread प्रोटोकॉल पर कार्रवाई शुरू करें:

> thread start
Done

कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस Thread लीडर बन गया है:

> state
leader
Done

2. कमिश्नर की भूमिका शुरू करें

नोड 1 पर रहते हुए, कमिश्नर की भूमिका शुरू करें:

> commissioner start
Done

J01NME जॉइनर क्रेडेंशियल वाले किसी भी जॉइनर को नेटवर्क पर कमीशन देने की अनुमति दें. इसके लिए, * वाइल्डकार्ड का इस्तेमाल करके ऐसा करें. जॉइनर एक ऐसा डिवाइस है जिसे कोई व्यक्ति एडमिन, मान्यता पा चुके Thread नेटवर्क में जोड़ता है.

> commissioner joiner add * J01NME
Done

J01NME, इस कोडलैब के लिए इस्तेमाल किया जाने वाला जॉइनर क्रेडेंशियल है, जिसे उपयोगकर्ता ने तय किया है. अगर आपको Thread नेटवर्क को किसी अलग तरीके से लागू करना है, तो 'जॉइनर' का कोई भी क्रेडेंशियल चुनें. जॉइनर क्रेडेंशियल, डिवाइस के हिसाब से बनी एक स्ट्रिंग है. इसमें अंग्रेज़ी के बड़े अक्षर वाले सभी वर्ण, यानी 0-9 और A-Y शामिल होते हैं. इनमें पढ़ने के लिहाज़ से I, O, Q, और Z शामिल नहीं होते. इसमें 6 से 32 वर्ण होते हैं. ज़्यादा जानकारी के लिए, थ्रेड कमीशन लेख पढ़ें.

3. जॉइनर की भूमिका शुरू करें

दूसरी टर्मिनल विंडो में, Docker कंटेनर में, एक नई सीएलआई प्रोसेस बनाएं. यह नोड 2 है.

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2

नोड 2 पर, J01NME जॉइनर क्रेडेंशियल का इस्तेमाल करके, जॉइनर की भूमिका चालू करें.

> ifconfig up
Done
> joiner start J01NME
Done

... पुष्टि के लिए कुछ सेकंड इंतज़ार करें ...

Join success

जॉइनर के तौर पर, डिवाइस (नोड 2) ने कमिश्नर (नोड 1) के साथ खुद की पुष्टि कर ली है और Thread नेटवर्क के क्रेडेंशियल पाए हैं.

अगर आपको Join failed का मैसेज मिलता है, तो हो सकता है कि 'शामिल होने का अनुरोध' प्रोसेस के लिए कमिश्नर का समय खत्म हो गया हो. ऐसी स्थिति में, commissioner joiner कमांड से रीस्टार्ट करें. कमिश्नर की भूमिका शुरू करने के बाद, जॉइनर की भूमिका को चालू करने में ज़्यादा समय न लगाएं.

शामिल होने के बाद आपको नोड 1 और 2 दोनों पर गड़बड़ी और/या लॉग संदेश भी मिल सकते हैं. ये सामान्य हैं और इन्हें अनदेखा किया जा सकता है.

नोड 2 की पुष्टि हो चुकी है, इसलिए अब Thread को शुरू करें:

> thread start
Done

4. नेटवर्क की पुष्टि करने की पुष्टि करें

नोड 2 पर state की जांच करके, यह पुष्टि करें कि अब वह नेटवर्क में शामिल हो गया है. दो मिनट में, नोड 2 child से router में बदल जाता है:

> state
child
Done
...
> state
router
Done

5. कॉन्फ़िगरेशन रीसेट करें

अगले एक्सरसाइज़ की तैयारी करने के लिए, कॉन्फ़िगरेशन को रीसेट करें. हर नोड पर, Thread को बंद करें, फ़ैक्ट्री रीसेट करें, और एम्युलेट किए गए Thread डिवाइस से बाहर निकलें:

> thread stop
Done
> factoryreset
>
> exit
root@c0f3912a74ff:/#

factoryreset निर्देश के बाद, > प्रॉम्प्ट को वापस लाने के लिए, आपको कुछ बार enter दबाना पड़ सकता है.

5. OpenThread Deemon की मदद से, नेटवर्क को मैनेज करें

इस काम के लिए, हम एक सीएलआई इंस्टेंस (एम्बेड किया गया एक SoC Thread डिवाइस) और एक रेडियो को-प्रोसेसर (आरसीपी) इंस्टेंस को सिम्युलेट करेंगे.

ot-daemon, OpenThread Posix ऐप्लिकेशन का मोड है. यह इनपुट और आउटपुट के तौर पर UNIX सॉकेट का इस्तेमाल करता है, ताकि OpenThread कोर को सेवा के तौर पर चलाया जा सके. क्लाइंट, OpenThread CLI को प्रोटोकॉल के तौर पर इस्तेमाल करके, सॉकेट से कनेक्ट करके इस सेवा से संपर्क कर सकता है.

ot-ctl एक सीएलआई है, जिसे ot-daemon उपलब्ध कराता है. यह आरसीपी को मैनेज और कॉन्फ़िगर करने के लिए उपलब्ध होता है. इसका इस्तेमाल करके, हम आरसीपी को Thread डिवाइस के बनाए गए नेटवर्क से कनेक्ट करेंगे.

डॉकर

इस एक्सरसाइज़ में मौजूद हर नोड (टर्मिनल विंडो) के लिए, पक्का करें कि आपने OpenThread बिल्ड के साथ Docker कंटेनर चलाया हो. अगर पिछली एक्सरसाइज़ के बाद जारी रखनी है, तो आपके पास उसी Docker कंटेनर में पहले से खुले हुए दो bash प्रॉम्प्ट होने चाहिए. अगर ऐसा नहीं है, तो डॉकर की समस्या हल करने का तरीका देखें.

ओट-डेमन का इस्तेमाल करें

इस अभ्यास में, नीचे दिए गए तीन टर्मिनल विंडो का इस्तेमाल किया जाएगा:

सिम्युलेट किए गए थ्रेड डिवाइस (नोड 1) का सीएलआई इंस्टेंस
ot-daemon प्रोसेस
ot-ctl सीएलआई इंस्टेंस

1. नोड 1 शुरू करें

पहली टर्मिनल विंडो में, अपने एम्युलेट किए गए Thread डिवाइस के लिए सीएलआई प्रोसेस को शुरू करें:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 13
Channel Mask: 07fff800
Ext PAN ID: 97d584bcd493b824
Mesh Local Prefix: fd55:cf34:dea5:7994/64
Network Key: ba6e886c7af50598df1115fa07658a83
Network Name: OpenThread-34e4
PAN ID: 0x34e4
PSKc: 38d6fd32c866927a4dfcc06d79ae1192
Security Policy: 0, onrcb
Done

इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

IPv6 इंटरफ़ेस खोलें:

> ifconfig up
Done

Thread प्रोटोकॉल पर कार्रवाई शुरू करें:

> thread start
Done

नोड 1 के Thread इंटरफ़ेस को असाइन किए गए IPv6 पते देखें:

> ipaddr
fd55:cf34:dea5:7994:0:ff:fe00:fc00
fd55:cf34:dea5:7994:0:ff:fe00:d000
fd55:cf34:dea5:7994:460:872c:e807:c4ab
fe80:0:0:0:9cd8:aab6:482f:4cdc
Done
>

जैसा कि Thread नेटवर्क को सिम्युलेट करें चरण में बताया गया है, एक पता लिंक-लोकल (fe80) और तीन मेश-लोकल (fd) होता है. ईआईडी, मेश नेटवर्क का एक ऐसा पता है जिसके पते में ff:fe00 नहीं होता. सैंपल के इस आउटपुट में, ईआईडी fd55:cf34:dea5:7994:460:872c:e807:c4ab है.

अपने ipaddr आउटपुट से उस ईआईडी की पहचान करें जिसका इस्तेमाल नोड से संपर्क करने के लिए किया जाएगा.

2. ओट-डेमन शुरू करें

दूसरी टर्मिनल विंडो में, tun डिवाइस नोड बनाएं और पढ़ने/लिखने की अनुमतियां सेट करें:

root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200
root@c0f3912a74ff:/# chmod 600 /dev/net/tun

इस डिवाइस का इस्तेमाल वर्चुअल डिवाइसों में पैकेट ट्रांसमिशन और रसीद की सुविधा के लिए किया जाता है. अगर डिवाइस पहले ही बना लिया गया है, तो आपको गड़बड़ी का मैसेज दिख सकता है. यह सामान्य बात है और इसे अनदेखा किया जा सकता है.

आरसीपी नोड के लिए ot-daemon शुरू करें, जिसे हम नोड 2 कहेंगे. -v वर्बोस फ़्लैग का इस्तेमाल करें, ताकि आप लॉग आउटपुट देख सकें और पुष्टि कर सकें कि यह चालू है:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'

पुष्टि हो जाने पर, वर्बोस मोड में, ot-daemon इस तरह का आउटपुट जनरेट करता है:

ot-daemon[31]: Running OPENTHREAD/297a880; POSIX; Feb  1 2022 04:43:39
ot-daemon[31]: Thread version: 3
ot-daemon[31]: Thread interface: wpan0
ot-daemon[31]: RCP version: OPENTHREAD/297a880; SIMULATION; Feb  1 2022 04:42:50

इस टर्मिनल को खुला रहने दें और बैकग्राउंड में चालू रखें. इसमें आपको कोई और निर्देश नहीं डालना होगा.

3. नेटवर्क में शामिल होने के लिए ot-ctl का इस्तेमाल करें

हमने अब तक किसी भी Thread नेटवर्क के लिए नोड 2 (ot-daemon आरसीपी) को चालू नहीं किया है. ऐसी ही स्थिति में ot-ctl की ज़रूरत पड़ती है. ot-ctl, उसी सीएलआई का इस्तेमाल करता है जो OpenThread सीएलआई ऐप्लिकेशन में किया गया है. इसलिए, ot-daemon नोड को सिम्युलेट किए गए अन्य Thread डिवाइसों की तरह ही कंट्रोल किया जा सकता है.

तीसरी टर्मिनल विंडो खोलें और मौजूदा कंटेनर को लागू करें:

$ docker exec -it codelab_otsim_ctnr bash

कंटेनर में पहुंचने के बाद, ot-ctl शुरू करें:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl
>

आपको इस तीसरी टर्मिनल विंडो में ot-ctl का इस्तेमाल, ot-daemon के साथ दूसरी टर्मिनल विंडो में शुरू किए गए नोड 2 (आरसीपी नोड) को मैनेज करने के लिए करना होगा. नोड 2 के state की जांच करें:

> state
disabled
Done

नोड 2 का eui64 पाएं, ताकि किसी खास जॉइनर में शामिल होने पर पाबंदी लगाई जा सके:

> eui64
18b4300000000001
Done

नोड 1 (पहली टर्मिनल विंडो) पर, कमिश्नर को शुरू करें और सिर्फ़ उस eui64 से ही शामिल करें:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

तीसरी टर्मिनल विंडो में, नोड 2 का नेटवर्क इंटरफ़ेस लाएं और नेटवर्क से जुड़ें:

> ifconfig up
Done
> joiner start J01NME
Done

... पुष्टि के लिए कुछ सेकंड इंतज़ार करें ...

Join success

आरसीपी (नोड 2) को जॉइनर के तौर पर, कमिश्नर (नोड 1) के साथ खुद की पुष्टि कर ली है और Thread नेटवर्क के क्रेडेंशियल मिल गए हैं.

अब Thread नेटवर्क में नोड 2 को जोड़ें (फिर से तीसरी टर्मिनल विंडो में):

> thread start
Done

4. नेटवर्क की पुष्टि करने की पुष्टि करें

तीसरे टर्मिनल में, नोड 2 पर state की जांच करके पुष्टि करें कि अब वह नेटवर्क में शामिल हो गया है. दो मिनट में, नोड 2 child से router में बदल जाता है:

> state
child
Done
...
> state
router
Done

5. कनेक्टिविटी की पुष्टि करें

तीसरी टर्मिनल विंडो में, Ctrl+D या exit निर्देश का इस्तेमाल करके ot-ctl से बाहर निकलें. इसके बाद, कंटेनर के bash कंसोल पर वापस जाएं. इस कंसोल से, ping Node 1, इसके ईआईडी का इस्तेमाल ping6 कमांड के साथ करता है. अगर ot-daemon आरसीपी इंस्टेंस, Thread नेटवर्क से कनेक्ट हो जाता है और उससे कनेक्ट हो जाता है, तो पिंग ये काम करता है:

root@c0f3912a74ff:/# ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab
PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms
64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms
--- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms

6. Docker समस्या हल करना

अगर आप Docker कंटेनर से बाहर निकल चुके हैं, तो

bash प्रॉम्प्ट, आपको यह देखना पड़ सकता है कि यह चल रहा है या नहीं. इसके बाद, डिवाइस को रीस्टार्ट करें / ज़रूरत के हिसाब से फिर से डालें. अगर आपने किसी Docker कंटेनर में --rm विकल्प का इस्तेमाल नहीं किया है, तो वह अब भी मौजूद होना चाहिए.

यह दिखाने के लिए कि कौनसे Docker कंटेनर चल रहे हैं:

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

सभी Docker कंटेनर (चल रहे और बंद किए गए दोनों) दिखाने के लिए:

$ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

अगर आपको docker ps कमांड के आउटपुट में कंटेनर codelab_otsim_ctnr नहीं दिखता है, तो उसे फिर से चलाएं:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

अगर आपको कंटेनर से बाहर निकलने के बाद, कंटेनर को मिटाना है, तो सिर्फ़ --rm विकल्प का इस्तेमाल करें.

अगर कंटेनर बंद हो गया है (docker ps -a में मौजूद है, लेकिन docker ps में नहीं), तो उसे रीस्टार्ट करें:

$ docker start -i codelab_otsim_ctnr

अगर Docker कंटेनर पहले से चल रहा है (docker ps में दी गई सूची में), तो हर टर्मिनल में कंटेनर से फिर से कनेक्ट करें:

$ docker exec -it codelab_otsim_ctnr bash

"ऑपरेशन की अनुमति नहीं है" गड़बड़ियां

अगर mknod कमांड का इस्तेमाल करके नए OpenThread नोड बनाते समय Operation not permitted गड़बड़ियां होती हैं, तो पक्का करें कि इस कोडलैब में दिए गए निर्देशों के मुताबिक, Docker को रूट उपयोगकर्ता के तौर पर चलाया जा रहा हो. यह कोडलैब, Docker को रूटलेस मोड में चलाने की सुविधा नहीं देता.

7. बधाई हो!

आपने OpenThread का इस्तेमाल करके, अपने पहले Thread नेटवर्क को सिम्युलेट कर दिया है. बहुत बढ़िया!

इस कोडलैब में, आपने ये काम करने का तरीका सीखा:

OpenThread सिम्युलेशन Docker कंटेनर शुरू और मैनेज करें
Thread नेटवर्क को सिम्युलेट करें
थ्रेड नोड की पुष्टि करें
OpenThread Deemon की मदद से, Thread नेटवर्क को मैनेज करना

Thread और OpenThread के बारे में ज़्यादा जानने के लिए, ये रेफ़रंस देखें:

इसके अलावा, Docker कंटेनर में OpenThread Border राऊटर का इस्तेमाल करके देखें!