‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

הדמיה של רשת פרוטוקול 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.

מה תלמדו

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

יצירת הרשת

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 מדומה בסדנת הקוד הזו ישתמש בתיאור קובץ שונה.

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

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

> factoryreset
>
> exit
root@c0f3912a74ff:/#

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

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

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

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

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

Docker

בכל תרגיל שנותר (חלון מסוף) צריך לוודא שמריצים את קונטיינר 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

בכל צומת (חלון טרמינל) בתרגיל הזה, צריך לוודא שמריצים את מאגר Docker עם ה-build של 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 של Node 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 (ה-ot-daemon RCP) באף רשת 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 (חלון הטרמינל הראשון), מפעילים את המפקח ומגבילים את ההצטרפות רק ל-eui64 הזה:

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

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

> ifconfig up
Done
> joiner start J01NME
Done

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

Join success

כמצטרף, ה-RCP (צומת 2) אימת את עצמו בהצלחה מול ה-Commissioner (צומת 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

אם לא מופיע קטע container 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