Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Halaman ini diterjemahkan oleh Cloud Translation API.

Menyimulasikan jaringan Thread menggunakan OpenThread di Docker

1. Pengantar

26b7f4f6b3ea0700.pngS

OpenThread yang dirilis oleh Google merupakan implementasi open source dari protokol jaringan Thread. Google Nest telah merilis OpenThread untuk membuat teknologi yang digunakan dalam produk Nest tersedia secara luas bagi developer guna mempercepat pengembangan produk untuk rumah yang terhubung.

Spesifikasi Thread mendefinisikan protokol komunikasi perangkat-ke-perangkat berbasis IPv6 yang andal, aman, dan rendah daya untuk aplikasi rumah. OpenThread menerapkan semua lapisan jaringan Thread termasuk IPv6, 6LoWPAN, IEEE 802.15.4 dengan keamanan MAC, Pembentukan Link Mesh, dan Perutean Mesh.

Codelab ini akan memandu Anda melakukan simulasi jaringan Thread pada perangkat yang diemulasi menggunakan Docker.

Yang akan Anda pelajari

Cara menyiapkan toolchain build OpenThread
Cara menyimulasikan jaringan Thread
Cara mengautentikasi node Thread
Cara mengelola jaringan Thread dengan OpenThread Daemon

Yang Anda butuhkan

Docker
Pengetahuan dasar tentang Linux, pemilihan rute jaringan

2. Menyiapkan Docker

Codelab ini dirancang untuk menggunakan Docker di mesin Linux, Mac OS X, atau Windows. Linux adalah lingkungan yang direkomendasikan.

Instal Docker

Instal Docker di OS pilihan Anda.

Mengambil image Docker

Setelah Docker terinstal, buka jendela terminal dan ambil image Docker openthread/environment. Gambar ini menampilkan OpenThread dan OpenThread Daemon yang telah dibuat sebelumnya dan siap digunakan untuk Codelab ini.

$ docker pull openthread/environment:latest

Perhatikan bahwa mungkin butuh waktu beberapa menit untuk mengunduh sepenuhnya.

Di jendela terminal, mulai container Docker dari image dan hubungkan ke shell bash:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Opsi --rm menghapus penampung saat Anda keluar dari penampung. Jangan gunakan opsi ini jika Anda tidak ingin penampung dihapus.

Perhatikan flag yang diperlukan untuk Codelab ini:

--sysctl net.ipv6.conf.all.disable_ipv6=0 — tindakan ini mengaktifkan IPv6 dalam container
--cap-add=net_admin — mengaktifkan kemampuan NET_ADMIN, yang memungkinkan Anda menjalankan operasi terkait jaringan, seperti menambahkan rute IP

Setelah berada di container, Anda akan melihat perintah seperti ini:

root@c0f3912a74ff:/#

Dalam contoh di atas, c0f3912a74ff adalah ID Penampung. ID Container untuk instance container Docker Anda akan berbeda dengan yang ditampilkan pada perintah untuk Codelab ini.

Menggunakan Docker

Codelab ini mengasumsikan bahwa Anda mengetahui dasar-dasar penggunaan Docker. Anda harus tetap berada di container Docker untuk seluruh Codelab.

3. Menyimulasikan jaringan Thread

Aplikasi contoh yang akan Anda gunakan untuk Codelab ini menunjukkan aplikasi OpenThread minimal yang mengekspos antarmuka konfigurasi dan pengelolaan OpenThread melalui antarmuka command line (CLI) dasar.

Latihan ini akan memandu Anda melakukan langkah-langkah minimal yang diperlukan untuk melakukan ping pada satu perangkat Thread yang diemulasi dari perangkat Thread lain yang diemulasikan.

Gambar di bawah ini menjelaskan topologi jaringan Thread dasar. Untuk latihan ini, kita akan mengemulasi dua node dalam lingkaran hijau: Thread Leader dan Thread Router dengan satu koneksi di antara keduanya.

6e3aa07675f902dc.pngS

Membuat jaringan

1. Mulai Node 1

Jika Anda belum melakukannya, di jendela terminal, mulai container Docker dan hubungkan ke shell bash:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Di container Docker, munculkan proses CLI untuk perangkat Thread yang diemulasi menggunakan biner ot-cli-ftd.

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

Catatan: Jika Anda tidak melihat perintah > setelah menjalankan perintah ini, tekan enter.

Biner ini mengimplementasikan perangkat OpenThread. Driver radio IEEE 802.15.4 diimplementasikan di atas UDP (IEEE 802.15.4 frame yang diteruskan dalam payload UDP).

Argumen 1 adalah deskriptor file yang mewakili bit yang paling tidak signifikan dari "ditetapkan pabrik" IEEE EUI-64 untuk perangkat yang diemulasi. Nilai ini juga digunakan saat mengikat ke port UDP untuk emulasi radio IEEE 802.15.4 (port = 9000 + deskriptor file). Setiap instance perangkat Thread yang diemulasi dalam Codelab ini akan menggunakan deskriptor file yang berbeda.

Catatan: Hanya gunakan deskriptor file 1 atau yang lebih baru seperti yang disebutkan dalam Codelab ini saat menghasilkan proses untuk perangkat yang diemulasikan. Deskriptor file 0 dicadangkan untuk penggunaan lain.

Membuat Set Data Operasional baru dan melakukan commit sebagai yang aktif. Set Data Operasional adalah konfigurasi untuk jaringan Thread yang Anda buat.

> 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

Commit set data ini sebagai set data aktif:

> dataset commit active
Done

Munculkan antarmuka IPv6:

> ifconfig up
Done

Mulai operasi protokol Thread:

> thread start
Done

Tunggu beberapa detik dan verifikasi bahwa perangkat telah menjadi Pemimpin Thread. Leader adalah perangkat yang bertanggung jawab untuk mengelola penetapan ID router.

> state
leader
Done

Lihat alamat IPv6 yang ditetapkan ke antarmuka Thread Node 1 (output Anda akan berbeda):

> 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

Perhatikan jenis alamat IPv6 spesifik:

Diawali dengan fd = mesh-local
Diawali dengan fe80 = link-local

Jenis alamat mesh-lokal diklasifikasikan lebih lanjut:

Berisi ff:fe00 = Router Locator (RLOC)
Tidak berisi ff:fe00 = ID Endpoint (EID)

Identifikasi EID di output konsol Anda, catat untuk digunakan nanti. Dalam contoh output di atas, EID-nya adalah:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. Memulai Node 2

Buka terminal baru dan jalankan shell bash di container Docker yang sedang berjalan untuk digunakan dengan Node 2.

$ docker exec -it codelab_otsim_ctnr bash

Pada prompt bash baru ini, munculkan proses CLI dengan argumen 2. Ini adalah perangkat Thread kedua Anda yang diemulasi:

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

Catatan: Jika Anda tidak melihat perintah > setelah menjalankan perintah ini, tekan enter.

Konfigurasi Kunci Jaringan Thread dan ID PAN menggunakan nilai yang sama dengan Set Data Operasional Node 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Commit set data ini sebagai set data aktif:

> dataset commit active
Done

Munculkan antarmuka IPv6:

> ifconfig up
Done

Mulai operasi protokol Thread:

> thread start
Done

Perangkat akan melakukan inisialisasi sendiri sebagai Turunan. Turunan Thread setara dengan Perangkat Akhir, yang merupakan perangkat Thread yang mengirim dan menerima traffic unicast hanya dengan perangkat Induk.

> state
child
Done

Dalam waktu 2 menit, Anda akan melihat status beralih dari child menjadi router. Thread Router mampu mengarahkan traffic di antara perangkat Thread. Tindakan ini juga disebut sebagai Induk.

> state
router
Done

Memverifikasi jaringan

Cara mudah untuk memverifikasi jaringan mesh adalah dengan melihat tabel router.

1. Memeriksa konektivitas

Di Node 2, dapatkan RLOC16. RLOC16 adalah 16 bit terakhir dari alamat IPv6 RLOC perangkat.

> rloc16
5800
Done

Di Node 1, periksa tabel router untuk RLOC16 Node 2. Pastikan Node 2 telah dialihkan ke status router terlebih dahulu.

> 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 Node 2 dari 0x5800 ditemukan dalam tabel, yang mengonfirmasi bahwa RLOC tersebut terhubung ke mesh.

2. Melakukan ping ke Node 1 dari Node 2

Memverifikasi konektivitas antara dua perangkat Thread yang diemulasi. Di Node 2, ping EID yang ditetapkan ke Node 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

Tekan enter untuk kembali ke perintah CLI >.

Menguji jaringan

Setelah Anda berhasil melakukan ping di antara dua perangkat Thread yang diemulasikan, uji jaringan mesh dengan mengambil satu node secara offline.

Kembali ke Node 1 dan hentikan Thread:

> thread stop
Done

Beralihlah ke Node 2 dan periksa statusnya. Dalam waktu dua menit, Node 2 mendeteksi bahwa pemimpin (Node 1) sedang offline, dan Anda akan melihat transisi Node 2 menjadi leader jaringan:

> state
router
Done
...
> state
leader
Done

Setelah dikonfirmasi, hentikan Thread dan reset Node 2 ke setelan pabrik sebelum keluar kembali ke perintah bash Docker. Reset ke setelan pabrik dilakukan untuk memastikan bahwa kredensial jaringan Thread yang kami gunakan dalam latihan ini tidak dibawa ke latihan berikutnya.

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

Anda mungkin harus menekan enter beberapa kali untuk mengembalikan prompt > setelah perintah factoryreset. Jangan keluar dari container Docker.

Selain itu, reset ke setelan pabrik dan keluar dari Node 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Lihat Referensi CLI OpenThread untuk mempelajari semua perintah CLI yang tersedia.

4. Mengautentikasi node dengan Commissioning

Pada latihan sebelumnya, Anda akan menyiapkan jaringan Thread dengan dua perangkat simulasi dan konektivitas terverifikasi. Namun, tindakan ini hanya mengizinkan traffic link-local IPv6 yang tidak diautentikasi untuk diteruskan antar-perangkat. Untuk mengarahkan traffic IPv6 global di antara node (dan Internet melalui router pembatas Thread), node harus diautentikasi.

Untuk mengautentikasi, satu perangkat harus bertindak sebagai Commissioner. Commissioner adalah server autentikasi yang dipilih saat ini untuk perangkat Thread baru, dan pemberi otorisasi untuk memberikan kredensial jaringan yang diperlukan agar perangkat dapat bergabung ke jaringan.

Dalam latihan ini, kita akan menggunakan topologi dua node yang sama seperti sebelumnya. Untuk autentikasi, Thread Leader akan bertindak sebagai Commissioner, yaitu Router Thread sebagai Joiner.

Docker

Untuk setiap Node (jendela terminal) dalam latihan yang tersisa, pastikan Anda menjalankan container Docker dengan build OpenThread. Jika melanjutkan dari latihan sebelumnya, Anda seharusnya masih memiliki dua prompt bash dalam container Docker yang sudah terbuka. Jika tidak, lihat langkah Pemecahan Masalah Docker, atau cukup ulangi latihan Simulasikan jaringan Thread.

1. Membuat jaringan

Di Node 1, munculkan proses CLI:

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

Catatan: Jika Anda tidak melihat perintah > setelah menjalankan perintah ini, tekan enter.

Buat Set Data Operasional baru, komitmenkan sebagai yang aktif, dan mulai Thread:

> 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

Commit set data ini sebagai set data aktif:

> dataset commit active
Done

Munculkan antarmuka IPv6:

> ifconfig up
Done

Mulai operasi protokol Thread:

> thread start
Done

Tunggu beberapa detik, lalu verifikasi bahwa perangkat telah menjadi Pemimpin Thread:

> state
leader
Done

2. Memulai peran Komisaris

Saat masih berada di Node 1, mulailah peran Commissioner:

> commissioner start
Done

Izinkan Joiner apa pun (dengan menggunakan karakter pengganti *) dengan Kredensial Joiner J01NME untuk melakukan komisi ke jaringan. Joiner adalah perangkat yang ditambahkan oleh administrator manusia ke Jaringan Thread yang ditugaskan.

> commissioner joiner add * J01NME
Done

3. Memulai peran Joiner

Di jendela terminal kedua, di container Docker, munculkan proses CLI baru. Ini adalah Node 2.

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

Di Node 2, aktifkan peran Joiner menggunakan Kredensial Joiner J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... tunggu beberapa detik untuk konfirmasi ...

Join success

Sebagai Joiner, perangkat (Node 2) telah berhasil mengautentikasi dirinya dengan Commissioner (Node 1) dan menerima kredensial Jaringan Thread.

Setelah Node 2 diautentikasi, mulai Thread:

> thread start
Done

4. Memvalidasi autentikasi jaringan

Periksa state pada Node 2, untuk memvalidasi bahwa node tersebut sekarang telah bergabung dengan jaringan. Dalam waktu dua menit, Node 2 bertransisi dari child ke router:

> state
child
Done
...
> state
router
Done

5. Reset konfigurasi

Untuk mempersiapkan latihan berikutnya, reset konfigurasi. Di setiap Node, hentikan Thread, lakukan reset ke setelan pabrik, dan keluar dari perangkat Thread yang diemulasi:

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

Anda mungkin harus menekan enter beberapa kali untuk mengembalikan prompt > setelah perintah factoryreset.

5. Mengelola jaringan dengan OpenThread Daemon

Untuk latihan ini, kita akan menyimulasikan satu instance CLI (satu perangkat SoC Thread tersemat) dan satu instance Radio Co-Processor (RCP).

ot-daemon adalah mode aplikasi OpenThread Posix yang menggunakan soket UNIX sebagai input dan output sehingga core OpenThread dapat berjalan sebagai layanan. Klien dapat berkomunikasi dengan layanan ini dengan terhubung ke soket menggunakan OpenThread CLI sebagai protokol.

ot-ctl adalah CLI yang disediakan oleh ot-daemon untuk mengelola dan mengonfigurasi RCP. Dengan menggunakan ini, kita akan menghubungkan RCP ke jaringan yang dibuat oleh perangkat Thread.

Docker

Untuk setiap Node (jendela terminal) dalam latihan ini, pastikan Anda menjalankan container Docker dengan build OpenThread. Jika melanjutkan dari latihan sebelumnya, Anda akan memiliki dua prompt bash dalam container Docker yang sama yang sudah terbuka. Jika tidak, lihat langkah Pemecahan Masalah Docker.

Gunakan ot-daemon

Latihan ini akan menggunakan tiga jendela terminal, sesuai dengan berikut ini:

Instance CLI dari perangkat Thread yang disimulasikan (Node 1)
ot-daemon proses
Instance CLI ot-ctl

1. Mulai Node 1

Di jendela terminal pertama, munculkan proses CLI untuk perangkat Thread yang diemulasikan:

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

Catatan: Jika Anda tidak melihat perintah > setelah menjalankan perintah ini, tekan enter.

Buat Set Data Operasional baru, komitmenkan sebagai yang aktif, dan mulai Thread:

> 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

Commit set data ini sebagai set data aktif:

> dataset commit active
Done

Munculkan antarmuka IPv6:

> ifconfig up
Done

Mulai operasi protokol Thread:

> thread start
Done

Lihat alamat IPv6 yang ditetapkan ke antarmuka 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
>

Seperti yang dijelaskan dalam langkah Simulasikan jaringan Thread, satu alamat adalah link-local (fe80) dan tiga alamatnya adalah mesh-local (fd). EID adalah alamat mesh-local yang tidak berisi ff:fe00 di alamatnya. Dalam contoh output ini, EID-nya adalah fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Identifikasi EID spesifik dari output ipaddr Anda, yang akan digunakan untuk berkomunikasi dengan node.

2. Mulai ot-daemon

Di jendela terminal kedua, buat node perangkat tun dan tetapkan izin baca/tulis:

root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200
root@c0f3912a74ff:/# chmod 600 /dev/net/tun

Perangkat ini digunakan untuk transmisi dan penerimaan paket di perangkat virtual. Anda mungkin mendapatkan error jika perangkat telah dibuat—ini normal dan dapat diabaikan.

Mulai ot-daemon untuk node RCP, yang akan kita sebut Node 2. Gunakan flag panjang -v sehingga Anda dapat melihat output log dan memastikan bahwa flag sedang berjalan:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'

Jika berhasil, ot-daemon dalam mode panjang akan menghasilkan output yang mirip dengan berikut ini:

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

Biarkan terminal ini tetap terbuka dan berjalan di latar belakang. Anda tidak akan memasukkan perintah lebih lanjut di dalamnya.

3. Gunakan ot-ctl untuk bergabung dengan jaringan

Kami belum meminta Node 2 (RCP ot-daemon) ke jaringan Thread mana pun. Di sinilah ot-ctl berperan. ot-ctl menggunakan CLI yang sama dengan aplikasi OpenThread CLI. Oleh karena itu, Anda dapat mengontrol node ot-daemon dengan cara yang sama seperti simulasi perangkat Thread lainnya.

Buka jendela terminal ketiga dan jalankan container yang ada:

$ docker exec -it codelab_otsim_ctnr bash

Setelah berada di penampung, mulai ot-ctl:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl
>

Anda akan menggunakan ot-ctl di jendela terminal ketiga ini untuk mengelola Node 2 (node RCP) yang Anda mulai di jendela terminal kedua dengan ot-daemon. Periksa state Node 2:

> state
disabled
Done

Dapatkan eui64 Node 2, untuk membatasi penggabungan ke Joiner tertentu:

> eui64
18b4300000000001
Done

Di Node 1 (jendela terminal pertama), mulai Commissioner dan batasi penggabungan hanya ke eui64 tersebut:

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

Di jendela terminal ketiga, munculkan antarmuka jaringan untuk Node 2 dan hubungkan ke jaringan:

> ifconfig up
Done
> joiner start J01NME
Done

... tunggu beberapa detik untuk konfirmasi ...

Join success

Sebagai Joiner, RCP (Node 2) telah berhasil mengautentikasi dirinya dengan Commissioner (Node 1) dan menerima kredensial Thread Network.

Sekarang, gabungkan Node 2 ke jaringan Thread (lagi, di jendela terminal ketiga):

> thread start
Done

4. Memvalidasi autentikasi jaringan

Pada terminal ketiga, periksa state pada Node 2, untuk memvalidasi bahwa ia sekarang telah bergabung dengan jaringan. Dalam waktu dua menit, Node 2 bertransisi dari child ke router:

> state
child
Done
...
> state
router
Done

5. Validasi konektivitas

Di jendela terminal ketiga, keluar dari ot-ctl dengan menggunakan perintah Ctrl+D atau exit, lalu kembali ke konsol bash container. Dari konsol ini, lakukan ping ke Node 1 menggunakan EID-nya dengan perintah ping6. Jika instance RCP ot-daemon berhasil dihubungkan dan berkomunikasi dengan jaringan Thread, ping akan berhasil:

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. Pemecahan Masalah Docker

Jika Anda telah keluar dari container Docker

bash perintah, Anda mungkin perlu memeriksa apakah proses berjalan dan mulai ulang / masukkan kembali sesuai kebutuhan. Setiap container Docker yang Anda buat saat tidak menggunakan opsi --rm harus tetap ada.

Untuk menunjukkan container Docker yang berjalan:

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Untuk menampilkan semua container Docker (baik yang berjalan maupun dihentikan):

$ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Jika Anda tidak melihat container codelab_otsim_ctnr dalam output salah satu perintah docker ps, jalankan lagi:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Hanya gunakan opsi --rm jika Anda ingin container dihapus setelah keluar dari container.

Jika container dihentikan (tercantum dalam docker ps -a, tetapi tidak dalam docker ps), mulai ulang container:

$ docker start -i codelab_otsim_ctnr

Jika container Docker sudah berjalan (tercantum di docker ps), hubungkan kembali ke container di setiap terminal:

$ docker exec -it codelab_otsim_ctnr bash

"Operasi tidak diizinkan" kesalahan

Jika mengalami error Operation not permitted saat membuat node OpenThread baru (menggunakan perintah mknod), pastikan Anda menjalankan Docker sebagai pengguna root sesuai dengan perintah yang diberikan dalam Codelab ini. Codelab ini tidak mendukung pengoperasian Docker dalam mode rootless.

7. Selamat!

Anda telah berhasil menyimulasikan jaringan Thread pertama Anda menggunakan OpenThread. Keren!

Dalam codelab ini, Anda telah mempelajari cara:

Memulai dan mengelola container Docker Simulasi OpenThread
Menyimulasikan jaringan Thread
Mengautentikasi node Thread
Mengelola jaringan Thread dengan OpenThread Daemon

Untuk mempelajari Thread dan OpenThread lebih lanjut, pelajari referensi berikut:

Atau, coba gunakan OpenThread Border Router dalam container Docker.