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