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

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

מה תלמדו

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

מה תצטרך להכין

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

2. הגדרת אביזר עגינה

Codecode זה מיועד לשימוש ב-Docker במחשב Linux , Mac OS X או Windows. Linux היא הסביבה המומלצת.

התקנה של אביזר עגינה

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

משיכת התמונה של תחנת עגינה

אחרי ההתקנה של אביזר העגינה, צריך לפתוח חלון מסוף ולשלוף את תמונת openthread/environment אביזר העגינה. תמונה זו כוללת את OpenThread ו-OpenThread Daemon שנוצרו מראש ומוכנים לשימוש ב-Codelab הזה.

$ docker pull openthread/environment:latest

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

בחלון ה-Terminal, פותחים מאגר של 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 הזה.

שימוש באביזר העגינה

ב-Codelab הזה אנחנו מניחים שאתם מכירים את העקרונות הבסיסיים של השימוש ב-Docker. אל תכללו במאגר התגים ב-Docker בשלמותו את ה-Codelab.

3. הדמיית רשת Thread

האפליקציה לדוגמה שבה תשתמשו עבור ה-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

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

$ docker exec -it codelab_otsim_ctnr bash

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

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

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

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

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

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

> dataset commit active
Done

מציגים את ממשק IPv6:

> ifconfig up
Done

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

> thread start
Done

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

> state
child
Done

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

> state
router
Done

אימות הרשת

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

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

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

> rloc16
5800
Done

בצומת 1, מחפשים את טבלת הנתב של Node 2's 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 |

ניתן למצוא את צומת ה-RLOC של 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

לחזרה אל ההודעה של ה-CLI של >, יש ללחוץ על enter.

בדיקת הרשת

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

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

> thread stop
Done

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

> state
router
Done
...
> state
leader
Done

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

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

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

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

> factoryreset
>
> exit
root@c0f3912a74ff:/#

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

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

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

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

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

d6a67e8a0d0b5dcb.png

עגינה

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

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) וקיבל את פרטי הכניסה של רשת השרשורים.

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

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

עגינה

עבור כל צומת (חלון טרמינל) בתרגיל הזה, חשוב לוודא שאתם מפעילים את מאגר ה-Docker עם ה-build של OpenThread. אם ממשיכים מהתרגיל הקודם, אמורות להופיע שתי הודעות bash באותו מאגר תגים של 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&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
>

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

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

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

פותחים חלון מסוף שלישי ומפעילים את המאגר הקיים:

$ 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

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

> 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) והוא קיבל את פרטי הכניסה לרשת שרשור.

עכשיו אפשר להצטרף לצומת 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 מחובר בהצלחה לרשת השרשור ומעביר אותה אליו, הפינג יצליח:

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

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 הזה למדתם איך:

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

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

לחלופין, אפשר לנסות להשתמש ב-OpenThread Border Router in a Docker console?