1. परिचय
Google ने OpenThread को रिलीज़ किया है. यह Thread नेटवर्किंग प्रोटोकॉल का ओपन सोर्स वर्शन है. Google Nest ने OpenThread को रिलीज़ किया है. इससे Nest प्रॉडक्ट में इस्तेमाल की गई टेक्नोलॉजी, डेवलपर के लिए बड़े पैमाने पर उपलब्ध हो जाएगी. इससे कनेक्टेड होम के लिए प्रॉडक्ट को तेज़ी से डेवलप किया जा सकेगा.
Thread स्पेसिफ़िकेशन, घर के ऐप्लिकेशन के लिए डिवाइस-से-डिवाइस के बीच कम पावर में वायरलेस तरीके से कम्यूनिकेट करने का एक भरोसेमंद और सुरक्षित प्रोटोकॉल तय करता है. यह प्रोटोकॉल, IPv6 पर आधारित है. OpenThread, Thread की सभी नेटवर्किंग लेयर लागू करता है. इनमें IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, और Mesh Routing शामिल हैं.
इस कोडलैब में, Docker का इस्तेमाल करके, इम्यूलेट किए गए डिवाइसों पर Thread नेटवर्क को सिम्युलेट करने का तरीका बताया गया है.
आपको क्या सीखने को मिलेगा
- OpenThread के लिए, बिल्ड टूलचेन को सेट अप करने का तरीका
- Thread नेटवर्क को सिम्युलेट करने का तरीका
- Thread नोड की पुष्टि करने का तरीका
- OpenThread Daemon की मदद से थ्रेड नेटवर्क को मैनेज करने का तरीका
आपको किन चीज़ों की ज़रूरत होगी
- Docker
- Linux और नेटवर्क राउटिंग की बुनियादी जानकारी
2. Docker को सेट अप करना
इस कोडलैब को Linux, Mac OS X या Windows मशीन पर Docker का इस्तेमाल करने के लिए डिज़ाइन किया गया है. Linux को इस्तेमाल करने का सुझाव दिया जाता है.
Docker इंस्टॉल करना
अपनी पसंद के ओएस पर Docker इंस्टॉल करें.
Docker इमेज पुल करना
Docker इंस्टॉल होने के बाद, टर्मिनल विंडो खोलें और openthread/environment Docker इमेज को पुल करें. इस इमेज में, OpenThread और OpenThread Daemon पहले से बने हुए हैं. साथ ही, इस Codelab के लिए इस्तेमाल करने के लिए तैयार हैं.
$ 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 डिवाइस को पिंग करने के लिए ज़रूरी चरणों के बारे में बताया गया है.
नीचे दी गई इमेज में, थ्रेड नेटवर्क टोपोलॉजी के बारे में बताया गया है. इस अभ्यास के लिए, हम हरे रंग के सर्कल में मौजूद दो नोड का इस्तेमाल करेंगे: थ्रेड लीडर और थ्रेड राउटर. इन दोनों के बीच एक कनेक्शन होगा.
नेटवर्क बनाना
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 बाइनरी का इस्तेमाल करके, थ्रेड डिवाइस का इम्यूलेशन करने के लिए सीएलआई प्रोसेस शुरू करें.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर यह निर्देश चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.
यह बाइनरी, OpenThread डिवाइस को लागू करती है. IEEE 802.15.4 रेडियो ड्राइवर को यूडीपी के ऊपर लागू किया जाता है. IEEE 802.15.4 फ़्रेम, यूडीपी पेलोड में पास किए जाते हैं.
1 का तर्क एक फ़ाइल डिस्क्रिप्टर है. यह इम्यूलेट किए गए डिवाइस के लिए, "फ़ैक्ट्री से असाइन किए गए" IEEE EUI-64 के सबसे कम सार्थक बिट को दिखाता है. इस वैल्यू का इस्तेमाल, IEEE 802.15.4 रेडियो इम्यूलेशन के लिए यूडीपी पोर्ट से बाइंड करते समय भी किया जाता है (पोर्ट = 9000 + फ़ाइल डिस्क्रिप्टर). इस कोडलैब में, थ्रेड डिवाइस के हर इंस्टेंस के लिए अलग-अलग फ़ाइल डिस्क्रिप्टर का इस्तेमाल किया जाएगा.
ध्यान दें: इस कोडलैब में बताए गए तरीके के मुताबिक, एम्युलेट किए गए डिवाइस के लिए प्रोसेस शुरू करते समय, सिर्फ़ 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 start Done
कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस, थ्रेड लीडर बन गया है. लीडर वह डिवाइस होता है जो राउटर आईडी असाइन करने की प्रोसेस को मैनेज करता है.
> state leader Done
नोड 1 के थ्रेड इंटरफ़ेस को असाइन किए गए 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
IPv6 पते के इन टाइप के बारे में ध्यान दें:
fdसे शुरू होता है = mesh-localfe80से शुरू होता है = लिंक-लोकल
मेश-लोकल पतों को आगे इन कैटगरी में बांटा गया है:
- इसमें
ff:fe00= राऊटर लोकेटर (आरएलओसी) शामिल है - इसमें
ff:fe00= एंडपॉइंट आइडेंटिफ़ायर (ईआईडी) शामिल नहीं है
अपनी कंसोल आउटपुट में EID की पहचान करें और इसे बाद में इस्तेमाल करने के लिए नोट कर लें. ऊपर दिए गए सैंपल आउटपुट में, ईआईडी यह है:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. नोड 2 शुरू करें
एक नया टर्मिनल खोलें और Node 2 के लिए, फ़िलहाल चल रहे Docker कंटेनर में bash शेल को एक्ज़ीक्यूट करें.
$ docker exec -it codelab_otsim_ctnr bash
इस नए bash प्रॉम्प्ट पर, 2 आर्ग्युमेंट के साथ CLI प्रोसेस शुरू करें. यह आपका दूसरा इम्यूलेट किया गया Thread डिवाइस है:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
ध्यान दें: अगर यह निर्देश चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.
नोड 1 के ऑपरेशनल डेटासेट की वैल्यू का इस्तेमाल करके, थ्रेड नेटवर्क की और पैन आईडी कॉन्फ़िगर करें:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
इस डेटासेट को चालू डेटासेट के तौर पर सेट करें:
> dataset commit active Done
IPv6 इंटरफ़ेस खोलें:
> ifconfig up Done
थ्रेड शुरू करने के प्रोटोकॉल का ऑपरेशन:
> thread start Done
डिवाइस, खुद को बच्चे के तौर पर सेट अप कर लेगा. थ्रेड चाइल्ड, एंड डिवाइस के बराबर होता है. यह एक थ्रेड डिवाइस होता है, जो सिर्फ़ पैरंट डिवाइस के साथ यूनिकास्ट ट्रैफ़िक भेजता और पाता है.
> state child Done
दो मिनट के अंदर, आपको स्थिति child से router में बदलती हुई दिखेगी. Thread राऊटर, Thread डिवाइसों के बीच ट्रैफ़िक को रूट कर सकता है. इसे माता-पिता या अभिभावक भी कहा जाता है.
> state router Done
नेटवर्क की पुष्टि करना
मेश नेटवर्क की पुष्टि करने का आसान तरीका, राऊटर टेबल देखना है.
1. कनेक्टिविटी की जांच करें
दूसरे नोड पर, RLOC16 पाएं. RLOC16, डिवाइस के RLOC IPv6 पते के आखिरी 16 बिट होते हैं.
> rloc16 5800 Done
नोड 1 पर, नोड 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 का RLOC 0x5800 मौजूद है. इससे पुष्टि होती है कि यह मेश से कनेक्ट है.
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
> CLI प्रॉम्प्ट पर वापस जाने के लिए, enter दबाएं.
नेटवर्क की जांच करना
अब जब दो इम्यूलेट किए गए Thread डिवाइसों के बीच पिंग किया जा सकता है, तो किसी एक नोड को ऑफ़लाइन करके मेश नेटवर्क की जांच करें.
नोड 1 पर वापस जाएं और थ्रेड बंद करें:
> thread stop Done
नोड 2 पर स्विच करें और स्थिति देखें. दो मिनट के अंदर, नोड 2 को पता चल जाता है कि लीडर (नोड 1) ऑफ़लाइन है. इसके बाद, आपको नोड 2 को नेटवर्क का leader बनते हुए दिखेगा:
> state router Done ... > state leader Done
पुष्टि हो जाने के बाद, Docker bash प्रॉम्प्ट पर वापस जाने से पहले, Thread को बंद करें और Node 2 को फ़ैक्ट्री रीसेट करें. फ़ैक्ट्री रीसेट इसलिए किया जाता है, ताकि इस अभ्यास में इस्तेमाल किए गए थ्रेड नेटवर्क के क्रेडेंशियल, अगले अभ्यास में न ले जाए जाएं.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
factoryreset कमांड के बाद, > प्रॉम्प्ट को वापस लाने के लिए, आपको enter को कुछ बार दबाना पड़ सकता है. Docker कंटेनर से बाहर न निकलें.
साथ ही, Node 1 को फ़ैक्ट्री रीसेट करें और उससे बाहर निकलें:
> factoryreset > > exit root@c0f3912a74ff:/#
उपलब्ध सभी सीएलआई कमांड के बारे में जानने के लिए, OpenThread सीएलआई का रेफ़रंस देखें.
4. कमीशनिंग की मदद से नोड की पुष्टि करना
पिछली कसरत में, आपने दो सिम्युलेटेड डिवाइसों के साथ एक थ्रेड नेटवर्क सेट अप किया था और कनेक्टिविटी की पुष्टि की थी. हालांकि, इससे सिर्फ़ बिना पुष्टि किए गए IPv6 लिंक-लोकल ट्रैफ़िक को डिवाइसों के बीच पास करने की अनुमति मिलती है. इनके बीच ग्लोबल IPv6 ट्रैफ़िक को रूट करने के लिए, नोड की पुष्टि की जानी चाहिए. साथ ही, थ्रेड बॉर्डर राउटर के ज़रिए इंटरनेट का इस्तेमाल करने के लिए भी नोड की पुष्टि की जानी चाहिए.
पुष्टि करने के लिए, किसी एक डिवाइस को कमिश्नर के तौर पर काम करना होगा. कमिश्नर, फ़िलहाल नए Thread डिवाइसों के लिए चुना गया पुष्टि करने वाला सर्वर है. साथ ही, यह डिवाइसों को नेटवर्क से जुड़ने के लिए ज़रूरी नेटवर्क क्रेडेंशियल देने वाला व्यक्ति है.
इस एक्सरसाइज़ में, हम पहले की तरह ही दो नोड वाली टोपोलॉजी का इस्तेमाल करेंगे. पुष्टि करने के लिए, Thread लीडर, कमिश्नर के तौर पर काम करेगा. वहीं, Thread राऊटर, जॉइनर के तौर पर काम करेगा.
Docker
बची हुई हर कसरत में, हर नोड (टर्मिनल विंडो) के लिए पक्का करें कि Docker कंटेनर, OpenThread बिल्ड के साथ चल रहा हो. अगर आपको पिछली कसरत से आगे बढ़ना है, तो आपके पास एक ही Docker कंटेनर में दो bash प्रॉम्प्ट खुले होने चाहिए. अगर ऐसा नहीं होता है, तो Docker से जुड़ी समस्या हल करने का तरीका देखें. इसके अलावा, थ्रेड नेटवर्क को सिम्युलेट करने की प्रोसेस को फिर से दोहराएं.
1. नेटवर्क बनाना
Node 1 में, CLI प्रोसेस को स्पॉन करें:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर यह निर्देश चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.
नया ऑपरेशनल डेटासेट बनाएं, उसे चालू के तौर पर सेट करें, और थ्रेड शुरू करें:
> 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 start Done
कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस Thread Leader बन गया है:
> state leader Done
2. कमिश्नर की भूमिका शुरू करना
नोड 1 पर रहते हुए, कमिश्नर की भूमिका शुरू करें:
> commissioner start Done
* वाइल्डकार्ड का इस्तेमाल करके, J01NME जॉइनर क्रेडेंशियल वाले किसी भी जॉइनर को नेटवर्क पर कमीशन करने की अनुमति दें. जॉइनर, ऐसा डिवाइस होता है जिसे कोई एडमिन, कमीशन किए गए Thread नेटवर्क में जोड़ता है.
> commissioner joiner add * J01NME Done
3. शामिल होने वाले व्यक्ति की भूमिका शुरू करना
दूसरी टर्मिनल विंडो में, Docker कंटेनर में नई सीएलआई प्रोसेस शुरू करें. यह नोड 2 है.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
दूसरे नोड पर, J01NME जॉइनर क्रेडेंशियल का इस्तेमाल करके, जॉइनर की भूमिका चालू करें.
> ifconfig up Done > joiner start J01NME Done
... पुष्टि होने तक कुछ सेकंड इंतज़ार करें ...
Join success
डिवाइस (नोड 2) ने जॉइनर के तौर पर, कमिश्नर (नोड 1) के साथ अपनी पुष्टि कर ली है. साथ ही, उसे Thread नेटवर्क के क्रेडेंशियल मिल गए हैं.
अब Node 2 की पुष्टि हो गई है. इसलिए, थ्रेड शुरू करें:
> thread start Done
4. नेटवर्क की पुष्टि करने की सुविधा की पुष्टि करना
नोड 2 पर state की जांच करें, ताकि यह पुष्टि की जा सके कि यह अब नेटवर्क से जुड़ गया है. दो मिनट के अंदर, नोड 2, child से router में बदल जाता है:
> state child Done ... > state router Done
5. कॉन्फ़िगरेशन रीसेट करना
अगली कसरत के लिए, कॉन्फ़िगरेशन को रीसेट करें. हर नोड पर, थ्रेड को बंद करें, फ़ैक्ट्री रीसेट करें, और थ्रेड डिवाइस का इस्तेमाल बंद करें:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
factoryreset कमांड के बाद, > प्रॉम्प्ट को वापस लाने के लिए, आपको enter को कुछ बार दबाना पड़ सकता है.
5. OpenThread Daemon की मदद से नेटवर्क मैनेज करना
इस एक्सरसाइज़ के लिए, हम एक सीएलआई इंस्टेंस (एक एम्बेड किया गया एसओसी थ्रेड डिवाइस) और एक रेडियो को-प्रोसेसर (आरसीपी) इंस्टेंस का सिम्युलेशन करेंगे.
ot-daemon, OpenThread Posix ऐप्लिकेशन का एक मोड है. यह इनपुट और आउटपुट के तौर पर UNIX सॉकेट का इस्तेमाल करता है, ताकि OpenThread कोर को सेवा के तौर पर चलाया जा सके. क्लाइंट, इस सेवा से कम्यूनिकेट कर सकता है. इसके लिए, उसे प्रोटोकॉल के तौर पर OpenThread CLI का इस्तेमाल करके सॉकेट से कनेक्ट करना होगा.
ot-ctl एक सीएलआई है. इसे ot-daemon ने आरसीपी को मैनेज और कॉन्फ़िगर करने के लिए उपलब्ध कराया है. इसका इस्तेमाल करके, हम आरसीपी को Thread डिवाइस से बनाए गए नेटवर्क से कनेक्ट करेंगे.
Docker
इस अभ्यास में हर नोड (टर्मिनल विंडो) के लिए, पक्का करें कि आपने OpenThread बिल्ड के साथ Docker कंटेनर चलाया हो. अगर आपको पिछले चरण से आगे बढ़ना है, तो आपके पास एक ही Docker कंटेनर में दो bash प्रॉम्प्ट पहले से खुले होने चाहिए. अगर ऐसा नहीं है, तो Docker से जुड़ी समस्या हल करने का तरीका देखें.
ot-daemon का इस्तेमाल करना
इस एक्सरसाइज़ में, तीन टर्मिनल विंडो का इस्तेमाल किया जाएगा. ये विंडो, यहां दी गई जानकारी के हिसाब से होंगी:
- सिम्युलेट किए गए Thread डिवाइस (नोड 1) का सीएलआई इंस्टेंस
ot-daemonप्रोसेसot-ctlसीएलआई इंस्टेंस
1. नोड 1 शुरू करें
पहली टर्मिनल विंडो में, अपने इम्यूलेट किए गए थ्रेड डिवाइस के लिए सीएलआई प्रोसेस शुरू करें:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर यह निर्देश चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.
नया ऑपरेशनल डेटासेट बनाएं, उसे चालू के तौर पर सेट करें, और थ्रेड शुरू करें:
> 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 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 >
थ्रेड नेटवर्क का सिम्युलेशन करें चरण में बताए गए तरीके के मुताबिक, एक पता लिंक-लोकल (fe80) और तीन मेश-लोकल (fd) हैं. ईआईडी, मेश-लोकल पता होता है. इसमें पते में ff:fe00 शामिल नहीं होता. इस सैंपल आउटपुट में, ईआईडी fd55:cf34:dea5:7994:460:872c:e807:c4ab है.
अपने ipaddr आउटपुट से उस ईआईडी की पहचान करें जिसका इस्तेमाल नोड से कम्यूनिकेट करने के लिए किया जाएगा.
2. ot-daemon शुरू करना
दूसरी टर्मिनल विंडो में, 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 का इस्तेमाल करना
हमने Node 2 (ot-daemon आरसीपी) को अब तक किसी भी Thread नेटवर्क के लिए चालू नहीं किया है. ऐसे में, ot-ctl आपकी मदद कर सकता है. ot-ctl, OpenThread CLI ऐप्लिकेशन की तरह ही CLI का इस्तेमाल करता है. इसलिए, ot-daemon नोड को उसी तरह से कंट्रोल किया जा सकता है जिस तरह से सिम्युलेट किए गए अन्य Thread डिवाइसों को कंट्रोल किया जाता है.
तीसरी टर्मिनल विंडो खोलें और मौजूदा कंटेनर को लागू करें:
$ docker exec -it codelab_otsim_ctnr bash
कंटेनर में शामिल होने के बाद, ot-ctl शुरू करें:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
ot-ctl का इस्तेमाल, इस तीसरी टर्मिनल विंडो में Node 2 (आरसीपी नोड) को मैनेज करने के लिए किया जाएगा. इसे आपने दूसरी टर्मिनल विंडो में ot-daemon की मदद से शुरू किया था. नोड 2 का state देखें:
> state disabled Done
किसी खास जॉइनर को शामिल होने से रोकने के लिए, Node 2 का eui64 पाएं:
> eui64 18b4300000000001 Done
नोड 1 (पहली टर्मिनल विंडो) पर, कमिश्नर शुरू करें और सिर्फ़ उस eui64 को शामिल होने की अनुमति दें:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
तीसरी टर्मिनल विंडो में, Node 2 के लिए नेटवर्क इंटरफ़ेस खोलें और नेटवर्क से जुड़ें:
> ifconfig up Done > joiner start J01NME Done
... पुष्टि होने तक कुछ सेकंड इंतज़ार करें ...
Join success
जॉइनर के तौर पर, आरसीपी (नोड 2) ने कमिश्नर (नोड 1) के साथ खुद की पुष्टि कर ली है. साथ ही, उसे थ्रेड नेटवर्क के क्रेडेंशियल मिल गए हैं.
अब नोड 2 को Thread नेटवर्क से जोड़ें. इसके लिए, तीसरी टर्मिनल विंडो में यह कमांड डालें:
> thread start Done
4. नेटवर्क की पुष्टि करने की सुविधा की पुष्टि करना
तीसरे टर्मिनल में, Node 2 पर state की जांच करें. इससे यह पुष्टि होगी कि अब यह नेटवर्क से जुड़ गया है. दो मिनट के अंदर, नोड 2, child से router में बदल जाता है:
> state child Done ... > state router Done
5. कनेक्टिविटी की पुष्टि करना
तीसरी टर्मिनल विंडो में, Ctrl+D या exit कमांड का इस्तेमाल करके ot-ctl से बाहर निकलें. इसके बाद, कंटेनर के bash कंसोल पर वापस जाएं. इस कंसोल से, ping6 कमांड का इस्तेमाल करके, Node 1 को उसके EID के साथ पिंग करें. अगर 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
"कार्रवाई की अनुमति नहीं है" गड़बड़ियां
अगर आपको Operation not permitted कमांड का इस्तेमाल करके नए OpenThread नोड बनाते समय Operation not permitted गड़बड़ियां मिलती हैं, तो पक्का करें कि आप इस Codelab में दिए गए निर्देशों के मुताबिक, Docker को रूट उपयोगकर्ता के तौर पर चला रहे हों.mknod इस कोडलैब में, रूटलेस मोड में Docker चलाने की सुविधा काम नहीं करती.
7. बधाई हो!
आपने OpenThread का इस्तेमाल करके, अपने पहले थ्रेड नेटवर्क को सिम्युलेट कर लिया है. बहुत बढ़िया!
इस कोडलैब में, आपने ये सीखा:
- OpenThread Simulation Docker कंटेनर को शुरू और मैनेज करना
- Thread नेटवर्क को सिम्युलेट करना
- Thread नोड की पुष्टि करना
- OpenThread Daemon की मदद से Thread नेटवर्क मैनेज करना
Thread और OpenThread के बारे में ज़्यादा जानने के लिए, इन लिंक पर जाएं:
- openthread.io पर Thread के बारे में बुनियादी जानकारी
- Thread की खास बातें
- OpenThread की GitHub रिपॉज़िटरी
- OpenThread CLI का रेफ़रंस
- OpenThread के लिए Docker की अतिरिक्त सुविधा
इसके अलावा, Docker कंटेनर में OpenThread बॉर्डर राऊटर का इस्तेमाल करके देखें!