סימולציה של רשת שרשור באמצעות OpenThread ב-Docker

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

מה תלמדו

  • איך מגדירים את ארגז הכלים של Openthread
  • איך מדמים רשת של Thread
  • איך לאמת צמתים של שרשור
  • איך לנהל רשת של Thread עם OpenThread Daemon

מה הדרישות כדי להצטרף לתוכנית?

  • אביזר עגינה
  • ידע בסיסי ב-Linux, ניתוב רשתות

2. הגדרת Docker

Codelab זה מיועד לשימוש ב-Docker ב-Linux, ב-Mac OS X או במחשב Windows. 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 מוחקת את המאגר כשיוצאים מהמאגר. אל תשתמשו באפשרות הזו אם אתם לא רוצים שהמאגר יימחק.

שימו לב לדגלים הנדרשים ב-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. סימולציה של רשת שרשורים

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

התרגיל הזה כולל את הפעולות המינימליות הנדרשות כדי לשלוח פינג למכשיר אמולטור אחד ממכשיר אמולציה אחר.

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

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 למכשיר עם שרשור אמולציה באמצעות הקובץ הבינארי 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 + מתאר הקובץ). כל מכונה של אמולציה של שרשור ב-Codelab הזה תשתמש בתיאור קובץ שונה.

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

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

> 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 = mesh-local
  • מתחיל ב-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. זהו התקן השרשור השני בהדמיה:

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. נתב שרשור יכול לנתב תנועה בין מכשירים שונים. הוא נקרא גם 'הורה'.

> state
router
Done

אימות הרשת

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

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

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

> rloc16
5800
Done

בצמתים 1, מחפשים את טבלת הנתב RLOC1 של צומת 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 נמצא בטבלה, ומאשר שהוא מחובר לרשת.

2. פינג צומת 1 מצומת 2

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

בדיקת הרשת

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

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

> thread stop
Done

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

> state
router
Done
...
> state
leader
Done

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

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

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

איפוס להגדרות המקוריות ויציאה מצומת 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

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

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

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

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

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

d6a67e8a0d0b5dcb.png

אביזר עגינה

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

1. יצירת רשת

בשדה 'צומת 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:

> thread start
Done

ממתינים כמה שניות ומוודאים שהמכשיר קיבל את הסטטוס 'מנהיג שרשור':

> state
leader
Done

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

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

> commissioner start
Done

מאפשרים לכל משתתף (באמצעות תו כללי לחיפוש *) להזין את פרטי ההתחברות של J01NME למשתמש לבצע עמלה על הרשת. Shareder הוא מכשיר שאדמין אנושי הוסיף אותו לרשת שרשור מקובלת.

> 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) אימת את עצמו בפני הנציב (צומת 1) וקיבל את פרטי הכניסה של Thread Network.

לאחר שהמערכת מאמתת את צומת 2, מתחילים את השרשור:

> thread start
Done

4. אימות הרשת

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

> state
child
Done
...
> state
router
Done

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

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

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

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

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

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

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

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

אביזר עגינה

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

שימוש ב-ot-daemon

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

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

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

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

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:

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

כפי שמוסבר בשלב סימולציה של רשת שרשור, כתובת אחת היא קישור מקומי (fe80) ושלוש הן רשת מקומית (fd). ה-EID הוא הכתובת המקומית ברשת שלא מכילה ff:fe00 בכתובת. בפלט לדוגמה הזה, ה-EID הוא fd55:cf34:dea5:7994:460:872c:e807:c4ab.

מזהה ה-EID הספציפי של פלט ipaddr שישמש לתקשורת עם הצומת.

2. התחלה של da-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 כדי להצטרף לרשת

עדיין לא הזמנו את צומת 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 בחלון הטרמינל השלישי כדי לנהל את צומת 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

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

> ifconfig up
Done
> joiner start J01NME
Done

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

Join success

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

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

> thread start
Done

4. אימות הרשת

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

> state
child
Done
...
> state
router
Done

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

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

סימנתם בהצלחה את רשת השרשורים הראשונה שלכם באמצעות OpenThread. נפלא!

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

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

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

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