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

קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

מה תלמדו

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

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

  • עגינה
  • ידע בסיסי ב-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

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

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 הוא מתאר הקובץ שמייצג את הביטים בעלי המשמעות הנמוכה ביותר של "fact-assigned" 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

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

> state
leader
Done

הצגת כתובות ה-IPv6 שהוקצו לממשק השרשור של צומת 1&#39 (הפלט שלך יהיה שונה):

> 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&33:

> 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

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

> state
router
Done

אימות הרשת

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

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

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

> rloc16
5800
Done

בצומת 1, בודקים את טבלת הנתב של RLOC16 של Node 2&33. מוודאים תחילה שצומת 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's של 0x5800 בטבלה, המאשר שהוא מחובר לרשת.

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.

בדיקת הרשת

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

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

> thread stop
Done

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

> state
router
Done
...
> state
leader
Done

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

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

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

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

> factoryreset
>
> exit
root@c0f3912a74ff:/#

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

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

עכשיו, כשצומת 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 כקלט ופלט, כדי שמערכת CoreThread תוכל לפעול כשירות. לקוחות יכולים לתקשר עם השירות הזה על ידי חיבור לשקע באמצעות פרוטוקול OpenThread CLI.

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

עגינה

בכל צומת (חלון טרמינל) בתרגיל הזה, חשוב לוודא שמריצים את הקונטיינר של Docker עם גרסת ה-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 שהוקצו לממשק השרשור של צומת 1&33:

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

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

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

עדיין לא הזמנתי את צומת 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, כדי להגביל את ההצטרפות למארגן הספציפי:

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

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

> 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 פועלות:

$ 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

אם הקונטיינר הופסק (מפורט ב-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 כמשתמש הבסיס בהתאם לפקודות שסופקו ב-Codelab הזה. ה-Codelab הזה לא תומך ב-Docker במצב בסיס.

7. כל הכבוד!

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

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

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

מידע נוסף על שרשור ועל OpenThread ניתן לעיין במאמרים הבאים:

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