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

1. מבוא

26b7f4f6b3ea0700.png

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

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

ה-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 מהתמונה ומתחברים למעטפת 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 עם חיבור יחיד ביניהם.

6e3aa07675f902dc.png

יצירת הרשת

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 מועברות בתוך מטענים ייעודיים (payloads) של UDP).

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

הערה: כשמתחילים את התהליך במכשיר אמולציה, צריך להשתמש בתיאורי קבצים מ-1 ומעלה כפי שצוין ב-Codelab הזה. מתאר קובץ של 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

ממתינים כמה שניות ומוודאים שהמכשיר הפך למוביל בשרשור. ה-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 = רשת מקומית
  • מתחיל ב-fe80 = link-local

סוגי כתובות מקומיות ברשת מסווגים עוד יותר:

  • מכיל ff:fe00 = מאתר הנתבים (RLOC)
  • לא מכיל ff:fe00 = מזהה של נקודת קצה (EID)

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

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

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

פותחים טרמינל חדש ומפעילים מעטפת bash בקונטיינר Docker שפועל כרגע כדי להשתמש בו לצומת 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

המכשיר יופעל כילד. 

> state
child
Done

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

> state
router
Done

אימות הרשת

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

1. צריך לבדוק את החיבור

ב-Node 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 של 0x5800 של צומת 2 מופיע בטבלה ומאשר שהוא מחובר לרשת.

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

כדי לחזור להנחיה > של ה-CLI, מקישים על enter.

בדיקת הרשת

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

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

> thread stop
Done

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

> state
router
Done
...
> state
leader
Done

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

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

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

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

> factoryreset
>
> exit
root@c0f3912a74ff:/#

בחומר העזר בנושא CLI של OpenThread תוכלו למצוא מידע על כל פקודות ה-CLI הזמינות.

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

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

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

בתרגיל זה נשתמש באותה טופולוגיה בעלת שתי צמתים כמו קודם. לצורך אימות, ה-thread Leader ישמש בתור הנציב, נתב ה-thread בתור join.

d6a67e8a0d0b5dcb.png

Docker

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

1. יצירת רשת

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

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

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

יוצרים מערך נתונים תפעולי חדש, שומרים אותו כמערך פעיל ומפעילים את פרוטוקול 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

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

> 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, מפעילים את התפקיד 'מצרף' באמצעות פרטי הכניסה של J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... עליך להמתין כמה שניות עד לאישור ...

Join success

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

עכשיו, לאחר שצומת 2 מאומת, מתחילים את פרוטוקול Thread:

> thread start
Done

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

בודקים את state ב-Node 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 מוטמע אחד) ומכונה אחת במעבד רדיו משותף (RCP).

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

ot-ctl הוא CLI שמסופק על ידי ot-daemon כדי לנהל ולהגדיר את ה-RCP. כך נחבר את ה-RCP לרשת שנוצרה במכשיר פרוטוקול Thread.

Docker

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

שימוש ב-ot-daemon

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

  1. מופע CLI של סימולציה של מכשיר Thread (צומת 1)
  2. תהליך אחד (ot-daemon)
  3. ot-ctl מופע של CLI

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

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

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

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

יוצרים מערך נתונים תפעולי חדש, שומרים אותו כמערך פעיל ומפעילים את פרוטוקול Thread:

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

כמו שמוסבר בשלב Simulate a Thread Network (סימולציה של רשת בפרוטוקול Thread), כתובת אחת היא מסוג link-local (fe80) ושלוש הן מחוברות לרשת מקומית (fd). ה-EID הוא כתובת מקומית ברשת שלא מכילה את 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 כדי לראות את פלט היומן ולוודא שהוא פועל:

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

> state
disabled
Done

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

> 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

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

עכשיו מצטרפים ל-Node 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. אם מכונת ה-RCP 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

אם הקונטיינר 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 במצב ללא שורש.

7. מעולה!

סיימת ליצור סימולציה של רשת פרוטוקול Thread הראשונה באמצעות OpenThread. מדהים!

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

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

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

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