1. מבוא
הגרסה 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. לצורך תרגיל זה, נבצע אמולציה של שני הצמתים בעיגול הירוק: מנהיג שרשור ונתב שרשור עם חיבור יחיד.
יצירת הרשת
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' (הפלט שלך יהיה שונה):
> 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 החדשים, והגורם המורשה לספק את פרטי הכניסה לרשת הנדרשים למכשירים כדי להצטרף לרשת.
בתרגיל הזה, נשתמש באותו טופולוגיה של שני צמתים כמו בעבר. לצורך אימות, מנהל השרשור יפעל כנציב, נתב השרשור כמחבר.
עגינה
עבור כל צומת (חלון טרמינל) בתרגילים הנותרים, יש לוודא שאתם מריצים את הקונטיינר של 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
בתרגיל הזה ייעשה שימוש בשלושה חלונות טרמינל, בהתאם לתקנים הבאים:
- מופע CLI של מכשיר עם שרשורי הדמיה (צומת 1)
- תהליך
ot-daemon
- מופע 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 ניתן לעיין במאמרים הבאים:
- Thread Primer ב-openthread.io
- מפרט שרשור
- מאגר OpenThread GitHub
- הפניה ל-CLI של OpenThread
- תמיכה נוספת ב-OpenThread Docker
אפשר גם לנסות להשתמש ב-OpenThread Border Router in מאגר Docker.