הדמיה של רשת פרוטוקול Thread באמצעות OpenThread ב-Docker

1. מבוא

‫OpenThread שפורסם על ידי Google הוא הטמעה בקוד פתוח של פרוטוקול הרשת Thread. ‫Google Nest פרסמה את OpenThread כדי להפוך את הטכנולוגיה שמשמשת במוצרי Nest לזמינה למפתחים באופן נרחב, במטרה להאיץ את פיתוח המוצרים לבית החכם.

במפרט של Thread מוגדר פרוטוקול תקשורת אלחוטי אמין ומאובטח בין מכשירים, שמבוסס על IPv6 וצורך מעט חשמל, לשימוש באפליקציות ביתיות. ‫OpenThread מטמיע את כל שכבות הרשת של Thread, כולל IPv6, ‏ 6LoWPAN, ‏ IEEE 802.15.4 עם אבטחת MAC, ‏ Mesh Link Establishment ו-Mesh Routing.

ב-Codelab הזה תלמדו איך לדמות רשת פרוטוקול Thread במכשירים וירטואליים באמצעות Docker.

מה תלמדו

איך מגדירים את כלי ה-build של OpenThread
איך מדמים רשת Thread
איך מאמתים צמתים של Thread
איך מנהלים רשת Thread באמצעות OpenThread Daemon

הדרישות

Docker
ידע בסיסי ב-Linux, ניתוב ברשת

2. הגדרת Docker

ה-Codelab הזה מיועד לשימוש ב-Docker במחשב עם Linux,‏ Mac OS X או Windows. מומלץ להשתמש בסביבת Linux.

התקנת Docker

מתקינים את Docker במערכת ההפעלה הרצויה.

משיכת קובץ האימג' של Docker

אחרי שמתקינים את Docker, פותחים חלון טרמינל ומושכים את קובץ אימג' של Docker‏ openthread/environment. בתמונה הזו מוצגים OpenThread ו-OpenThread Daemon שכבר נוצרו מראש ומוכנים לשימוש ב-Codelab הזה.

$ docker pull openthread/environment:latest

שימו לב: יכול להיות שיעברו כמה דקות עד שההורדה תושלם.

בחלון טרמינל, מפעילים קונטיינר של Docker מהאימג' ומתחברים ל-shell של 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 מוחקת את הקונטיינר כשיוצאים ממנו. אל תשתמשו באפשרות הזו אם אתם לא רוצים שהמאגר יימחק.

שימו לב לדגלים שנדרשים ל-Codelab הזה:

‫--sysctl net.ipv6.conf.all.disable_ipv6=0 – הפעלת IPv6 במאגר התגים
‫--cap-add=net_admin – מאפשרת את היכולת NET_ADMIN, שמאפשרת לבצע פעולות שקשורות לרשת, כמו הוספת נתיבי IP

אחרי שנכנסים למאגר התגים, אמורה להופיע הנחיה דומה לזו:

root@c0f3912a74ff:/#

בדוגמה שלמעלה, c0f3912a74ff הוא מזהה המאגר. מזהה מאגר התגים של מופע מאגר Docker יהיה שונה מזה שמוצג בהנחיות של ה-Codelab הזה.

שימוש ב-Docker

ב-Codelab הזה אנחנו מניחים שאתם מכירים את יסודות השימוש ב-Docker. צריך להישאר במיכל Docker למשך כל ה-Codelab.

3. סימולציה של רשת Thread

אפליקציית הדוגמה שתשתמשו בה ב-Codelab הזה מדגימה אפליקציית OpenThread מינימלית שחושפת את ממשקי התצורה והניהול של OpenThread באמצעות ממשק בסיסי של שורת פקודה (CLI).

במדריך הזה מוסבר איך לבצע את השלבים המינימליים שנדרשים כדי לשלוח פינג ממכשיר Thread אחד שמדמה מכשיר אחר של Thread.

באיור הבא מתוארת טופולוגיה בסיסית של רשת Thread. במסגרת התרגיל הזה, נדמה שני צמתים בתוך העיגול הירוק: Thread Leader ו-Thread Router עם חיבור יחיד ביניהם.

יצירת הרשת

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, מפעילים את תהליך ה-CLI עבור מכשיר Thread מדומה באמצעות קובץ הבינארי ot-cli-ftd.

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

הערה: אם ההודעה > לא מופיעה אחרי שמריצים את הפקודה הזו, לוחצים על enter.

הקובץ הבינארי הזה מטמיע מכשיר OpenThread. דרייבר הרדיו IEEE 802.15.4 מיושם על גבי UDP (פריימים של IEEE 802.15.4 מועברים בתוך מטען ייעודי (payload) של UDP).

הארגומנט של 1 הוא מתאר קובץ שמייצג את הסיביות הכי פחות משמעותיות של IEEE EUI-64 שמוקצה על ידי היצרן למכשיר המדומה. הערך הזה משמש גם כשמבצעים קישור ליציאת UDP לצורך הדמיה של רדיו IEEE 802.15.4 (יציאה = 9000 + מתאר קובץ). כל מופע של מכשיר Thread מדומה ב-Codelab הזה ישתמש בתיאור קובץ שונה.

הערה: כשמפעילים את התהליך של מכשיר מדומה, צריך להשתמש רק בתיאורי קבצים של 1 ומעלה, כמו שמוסבר ב-Codelab הזה. מתאר הקובץ 0 שמור לשימוש אחר.

יוצרים מערך נתונים תפעולי חדש ומבצעים commit שלו כמערך הנתונים הפעיל. מערך הנתונים התפעולי הוא ההגדרה של רשת 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 Leader. הנתב הראשי הוא המכשיר שאחראי לניהול ההקצאה של מזהה הנתב.

> state
leader
Done

צפייה בכתובות IPv6 שהוקצו לממשק Thread של צומת 1 (הפלט שלכם יהיה שונה):

> 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-local
מתחיל ב-fe80 = link-local

סוגי כתובות מקומיות ברשת Mesh מסווגים באופן הבא:

מכיל ff:fe00 = Router Locator (RLOC)
לא מכיל ff:fe00 = מזהה נקודת קצה (EID)

מזהים את ה-EID בפלט של המסוף ורושמים אותו לשימוש בהמשך. בדוגמת הפלט שלמעלה, מספר ה-EID הוא:

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

2. צומת התחלה 2

פותחים טרמינל חדש ומריצים bash shell במאגר Docker שפועל כרגע כדי להשתמש ב-Node 2.

$ docker exec -it codelab_otsim_ctnr bash

בהנחיה החדשה bash, מפעילים את תהליך ה-CLI עם הארגומנט 2. זהו מכשיר Thread השני שמדמה:

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

הערה: אם ההודעה > לא מופיעה אחרי שמריצים את הפקודה הזו, לוחצים על enter.

מגדירים את מפתח הרשת של Thread ואת מזהה ה-PAN, באמצעות אותם ערכים כמו במערך הנתונים התפעולי של צומת 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

מאשרים את מערך הנתונים הזה כמערך הנתונים הפעיל:

> dataset commit active
Done

פותחים את ממשק IPv6:

> ifconfig up
Done

התחלת פעולה של פרוטוקול Thread:

> thread start
Done

המכשיר יאותחל כילד או כילדה. מכשיר צאצא ב-Thread שווה ערך למכשיר קצה, שהוא מכשיר Thread שמשדר ומקבל תנועת נתונים מסוג unicast רק עם מכשיר אב.

> state
child
Done

תוך 2 דקות, המצב אמור להשתנות מ-child ל-router. נתב Thread יכול לנתב תעבורה בין מכשירים עם פרוטוקול Thread. הוא נקרא גם הורה.

> state
router
Done

אימות הרשת

דרך קלה לאמת את רשת האריג היא לבדוק את טבלת הנתב.

1. בדיקת הקישוריות

בצומת 2, מקבלים את RLOC16. ה-RLOC16 הוא 16 הביטים האחרונים של כתובת ה-IPv6 של ה-RLOC של המכשיר.

> rloc16
5800
Done

בצומת 1, בודקים את טבלת הניתוב של RLOC16 של צומת 2. קודם מוודאים שצומת 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 |

ה-RLOC של צומת 2,‏ 0x5800, מופיע בטבלה, מה שמאשר שהוא מחובר לרשת ה-Mesh.

2. ביצוע פינג לצומת 1 מצומת 2

מאמתים את הקישוריות בין שני מכשירי Thread מודמים. בצומת 2, ping מספר ה-EID שהוקצה לצומת 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 כדי לחזור להנחיית > CLI.

בדיקת הרשת

אחרי שבדקתם שאפשר לשלוח פינג בין שני מכשירי Thread מודמים, אתם יכולים לבדוק את רשת האריג על ידי העברה של צומת אחד למצב אופליין.

חוזרים לצומת 1 ומפסיקים את Thread:

> thread stop
Done

עוברים לצומת 2 ובודקים את המצב. תוך שתי דקות, צומת 2 מזהה שהצומת הראשי (צומת 1) במצב אופליין, ואתם אמורים לראות את צומת 2 עובר להיות leader של הרשת:

> state
router
Done
...
> state
leader
Done

אחרי האישור, מפסיקים את Thread ומאפסים להגדרות המקוריות את Node 2 לפני שיוצאים בחזרה להנחיית Docker bash. איפוס להגדרות המקוריות נעשה כדי לוודא שפרטי הכניסה לרשת פרוטוקול Thread שבהם השתמשנו בתרגיל הזה לא יועברו לתרגיל הבא.

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

יכול להיות שתצטרכו ללחוץ על enter כמה פעמים כדי שההנחיה > תופיע שוב אחרי פקודה factoryreset. אל תצאו ממאגר Docker.

בנוסף, מאפסים להגדרות המקוריות ויוצאים מ-Node 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

כדי לראות את כל הפקודות הזמינות של CLI, אפשר לעיין במדריך העזר של OpenThread CLI.

4. אימות צמתים באמצעות הפעלה

בתרגיל הקודם הגדרתם רשת Thread עם שני מכשירים מדומיים ואימתתם את הקישוריות. עם זאת, ההגדרה הזו מאפשרת רק לתנועת גולשים לא מאומתת ב-IPv6 ברשת המקומית לעבור בין מכשירים. כדי לנתב תנועת IPv6 גלובלית ביניהם (ובאינטרנט דרך נתב גבול Thread), הצמתים צריכים להיות מאומתים.

כדי לבצע אימות, מכשיר אחד צריך לפעול כמרכז בקרה. ה-Commissioner הוא שרת האימות שנבחר כרגע למכשירי Thread חדשים, והוא גם הגורם שמאשר את מתן פרטי הכניסה לרשת שנדרשים כדי שהמכשירים יוכלו להצטרף לרשת.

בתרגיל הזה נשתמש באותה טופולוגיה של שני צמתים כמו קודם. לצורך אימות, המכשיר הראשי ברשת Thread ישמש כנציב, ונתב Thread ישמש כמצטרף.

Docker

בכל תרגיל שנותר (חלון מסוף) של Node, מוודאים שמריצים את קונטיינר Docker עם גרסת ה-build של OpenThread. אם ממשיכים מהתרגיל הקודם, אמורים להיות פתוחים שני חלונות של bash באותו קונטיינר Docker. אם לא, אפשר לעיין בשלב פתרון בעיות ב-Docker או פשוט לחזור על התרגיל הדמיה של רשת Thread.

1. יצירת רשת

בצומת 1, מפעילים את תהליך ה-CLI:

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

הערה: אם ההודעה > לא מופיעה אחרי שמריצים את הפקודה הזו, לוחצים על enter.

יוצרים מערך נתונים תפעולי חדש, מבצעים commit שלו כמערך הפעיל ומתחילים שרשור:

> 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 Leader:

> state
leader
Done

2. הפעלת התפקיד 'נציב'

כשעדיין נמצאים בצומת 1, מתחילים את התפקיד של הנציב:

> commissioner start
Done

אפשר לאפשר לכל מצטרף (באמצעות התו הכללי *) עם אישור ההצטרפות J01NME להצטרף לרשת. מצטרף הוא מכשיר שמנהל אנושי מוסיף לרשת Thread שהופעלה.

> commissioner joiner add * J01NME
Done

3. התחלת התפקיד של המצטרף

בחלון מסוף שני, במאגר Docker, יוצרים תהליך CLI חדש. זה צומת 2.

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

בצומת 2, מפעילים את התפקיד Joiner באמצעות J01NME Joiner Credential.

> ifconfig up
Done
> joiner start J01NME
Done

... מחכים כמה שניות לאישור ...

Join success

המכשיר (Node 2) הצליח לאמת את עצמו מול הרכז (Node 1) וקיבל את פרטי הכניסה לרשת Thread.

אחרי שמאמתים את Node 2, מתחילים את Thread:

> thread start
Done

4. אימות של אימות הרשת

בודקים את state בצומת 2 כדי לוודא שהוא הצטרף לרשת. תוך שתי דקות, המעבר של צומת 2 הוא מ-child ל-router:

> state
child
Done
...
> state
router
Done

5. איפוס ההגדרה

כדי להתכונן לתרגיל הבא, מאפסים את ההגדרה. בכל צומת, מפסיקים את Thread, מאפסים להגדרות המקוריות ויוצאים ממכשיר Thread המדומה:

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

יכול להיות שתצטרכו ללחוץ על enter כמה פעמים כדי שההנחיה > תופיע שוב אחרי פקודה factoryreset.

5. ניהול הרשת באמצעות OpenThread Daemon

בתרגיל הזה נדמה מופע אחד של CLI (מכשיר SoC Thread מוטמע יחיד) ומופע אחד של Radio Co-Processor (RCP).

‫ot-daemon הוא מצב של אפליקציית OpenThread Posix שמשתמשת בשקע UNIX כקלט ופלט, כך שליבת OpenThread יכולה לפעול כשירות. לקוח יכול לתקשר עם השירות הזה על ידי התחברות לשקע באמצעות ה-CLI של OpenThread כפרוטוקול.

‫ot-ctl הוא CLI שמוצע על ידי ot-daemon לניהול ולהגדרה של ה-RCP. באמצעות הנתונים האלה, נחבר את ה-RCP לרשת שנוצרה על ידי מכשיר Thread.

Docker

בכל צומת (חלון Terminal) בתרגיל הזה, מוודאים שמריצים את קובץ ה-Docker עם הגרסה של OpenThread. אם אתם ממשיכים מהתרגיל הקודם, אמורות להיות לכם כבר פתוחות שתי הנחיות bash באותו קונטיינר Docker. אם לא, אפשר לעיין בשלב פתרון בעיות ב-Docker.

שימוש ב-ot-daemon

בתרגיל הזה נשתמש בשלושה חלונות מסוף, שמתאימים לפעולות הבאות:

מופע CLI של מכשיר Thread מדומה (צומת 1)
תהליך ot-daemon
מופע של ot-ctl CLI

1. צומת התחלה 1

בחלון הטרמינל הראשון, מפעילים את תהליך ה-CLI עבור מכשיר Thread המדומה:

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

הערה: אם ההודעה > לא מופיעה אחרי שמריצים את הפקודה הזו, לוחצים על enter.

יוצרים מערך נתונים תפעולי חדש, מבצעים commit שלו כמערך הפעיל ומתחילים שרשור:

> 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

צופים בכתובות ה-IPv6 שהוקצו לממשק Thread של צומת 1:

> 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, כתובת אחת היא link-local‏ (fe80) ושלוש הן mesh-local‏ (fd). ה-EID היא כתובת mesh-local שלא מכילה ff:fe00 בכתובת. בדוגמה הזו של פלט, מספר ה-EID הוא fd55:cf34:dea5:7994:460:872c:e807:c4ab.

מזהים את ה-EID הספציפי מתוך הפלט של 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 עבור צומת RCP, שנקרא לו צומת 2. משתמשים בדגל -v verbose כדי לראות את פלט היומן ולוודא שהסקריפט פועל:

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 (ה-RCP ot-daemon) באף רשת Thread. כאן נכנס לתמונה ot-ctl. ‫ot-ctl משתמש באותו CLI כמו אפליקציית OpenThread 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 (צומת ה-RCP) שהפעלתם בחלון הטרמינל השני באמצעות ot-daemon. בודקים את state של צומת 2:

> state
disabled
Done

כדי להגביל את ההצטרפות למשתתף ספציפי, מקבלים את eui64 של צומת 2:

> eui64
18b4300000000001
Done

בצומת 1 (חלון הטרמינל הראשון), מפעילים את ה-Commissioner ומגבילים את ההצטרפות רק ל-eui64 הזה:

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

בחלון השלישי של ה-Terminal, מציגים את ממשק הרשת של Node 2 ומצטרפים לרשת:

> ifconfig up
Done
> joiner start J01NME
Done

... מחכים כמה שניות לאישור ...

Join success

כמצטרף, ה-RCP (צומת 2) עבר אימות בהצלחה אצל הנציב (צומת 1) וקיבל את פרטי הכניסה לרשת Thread.

עכשיו מצטרפים עם צומת 2 לרשת Thread (שוב, בחלון הטרמינל השלישי):

> thread start
Done

4. אימות של אימות הרשת

בטרמינל השלישי, בודקים את state ב-Node 2 כדי לוודא שהוא הצטרף לרשת. תוך שתי דקות, המעבר של צומת 2 הוא מ-child ל-router:

> state
child
Done
...
> state
router
Done

5. אימות הקישוריות

בחלון הטרמינל השלישי, יוצאים מ-ot-ctl באמצעות Ctrl+D או הפקודה exit, וחוזרים למסוף bash של הקונטיינר. ממסוף זה, מריצים פינג ל-Node 1 באמצעות ה-EID שלו עם הפקודה ping6. אם מופע ot-daemon RCP מצטרף לרשת 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

אם לא מופיע קטע codelab_otsim_ctnr בפלט של אף אחת מהפקודות docker ps, מריצים אותה שוב:

$ 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 (באמצעות הפקודה mknod), אתם צריכים לוודא שאתם מריצים את Docker כמשתמש Root בהתאם לפקודות שמופיעות ב-Codelab הזה. ב-Codelab הזה אין תמיכה בהרצת Docker במצב ללא הרשאות root.

7. מעולה!

הדמייתם בהצלחה את רשת ה-Thread הראשונה באמצעות OpenThread. מדהים!

ב-Codelab הזה למדתם איך:

הפעלה וניהול של קונטיינר Docker של סימולציית OpenThread
סימולציה של רשת Thread
אימות של צמתי Thread
ניהול רשת Thread באמצעות OpenThread Daemon

מידע נוסף על Thread ו-OpenThread זמין במקורות המידע הבאים:

אפשר גם לנסות להשתמש ב-OpenThread Border Router בקונטיינר ב-Docker.

הדמיה של רשת פרוטוקול Thread באמצעות OpenThread ב-Docker קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

1. מבוא

מה תלמדו

הדרישות

2. הגדרת Docker

התקנת Docker

משיכת קובץ האימג' של Docker

שימוש ב-Docker

3. סימולציה של רשת Thread

יצירת הרשת

1. צומת התחלה 1

2. צומת התחלה 2

אימות הרשת

1. בדיקת הקישוריות

2. ביצוע פינג לצומת 1 מצומת 2

בדיקת הרשת

4. אימות צמתים באמצעות הפעלה

Docker

1. יצירת רשת

2. הפעלת התפקיד 'נציב'

3. התחלת התפקיד של המצטרף

4. אימות של אימות הרשת

5. איפוס ההגדרה

5. ניהול הרשת באמצעות OpenThread Daemon

Docker

שימוש ב-ot-daemon

1. צומת התחלה 1

2. הפעלת ot-daemon

3. שימוש ב-ot-ctl כדי להצטרף לרשת

4. אימות של אימות הרשת

5. אימות הקישוריות

6. פתרון בעיות ב-Docker

שגיאות מסוג "הפעולה אסורה"

7. מעולה!

הדמיה של רשת פרוטוקול Thread באמצעות OpenThread ב-Docker