1. Pengantar
OpenThread yang dirilis oleh Google adalah 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 menentukan protokol komunikasi nirkabel dari perangkat ke perangkat berbasis IPv6 yang andal, aman, dan berdaya rendah untuk aplikasi rumah. OpenThread mengimplementasikan 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 mensimulasikan jaringan Thread di 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, perutean 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 diinstal, buka jendela terminal dan tarik image Docker openthread/environment. Image ini menampilkan OpenThread dan OpenThread Daemon yang telah di-build sebelumnya dan siap digunakan untuk Codelab ini.
$ docker pull openthread/environment:latest
Perhatikan bahwa proses download mungkin memerlukan waktu beberapa menit hingga selesai.
Di jendela terminal, mulai container Docker dari image dan hubungkan ke shell bash-nya:
$ 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 container saat Anda keluar dari container. Jangan gunakan opsi ini jika Anda tidak ingin menghapus penampung.
Perhatikan tanda yang diperlukan untuk Codelab ini:
--sysctl net.ipv6.conf.all.disable_ipv6=0— 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 dalam container, Anda akan melihat perintah yang mirip dengan ini:
root@c0f3912a74ff:/#
Pada contoh di atas, c0f3912a74ff adalah ID Penampung. ID Penampung untuk instance penampung Docker Anda akan berbeda dengan yang ditampilkan dalam perintah untuk Codelab ini.
Menggunakan Docker
Codelab ini mengasumsikan bahwa Anda telah mengetahui dasar-dasar penggunaan Docker. Anda harus tetap berada di container Docker selama Codelab ini.
3. Mensimulasikan jaringan Thread
Contoh aplikasi 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 ke satu perangkat Thread yang diemulasi dari perangkat Thread lain yang diemulasi.
Gambar di bawah menjelaskan topologi jaringan Thread dasar. Untuk latihan ini, kita akan meniru dua node dalam lingkaran hijau: Thread Leader dan Thread Router dengan satu koneksi di antara keduanya.
Buat jaringan
1. Mulai Node 1
Jika Anda belum melakukannya, di jendela terminal, mulai container Docker dan hubungkan ke shell bash-nya:
$ 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, buat 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 (frame IEEE 802.15.4 diteruskan dalam payload UDP).
Argumen 1 adalah deskriptor file yang merepresentasikan bit yang paling tidak signifikan dari EUI-64 IEEE "yang ditetapkan pabrik" 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 besar seperti yang tercantum dalam Codelab ini saat membuat proses untuk perangkat yang diemulasi. Deskriptor file 0 dicadangkan untuk penggunaan lain.
Buat Set Data Operasional baru dan lakukan 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
Lakukan set data ini sebagai set data aktif:
> dataset commit active Done
Aktifkan antarmuka IPv6:
> ifconfig up Done
Operasi protokol Start Thread:
> thread start Done
Tunggu beberapa detik, lalu verifikasi bahwa perangkat telah menjadi Pemimpin Thread. Pemimpin 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 tertentu:
- Dimulai dengan
fd= mesh-local - Dimulai dengan
fe80= link-local
Jenis alamat lokal mesh diklasifikasikan lebih lanjut:
- Berisi
ff:fe00= Router Locator (RLOC) - Tidak berisi
ff:fe00= ID Endpoint (EID)
Identifikasi EID di output konsol Anda dan catat untuk digunakan nanti. Dalam contoh output di atas, EID-nya adalah:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Mulai Node 2
Buka terminal baru dan jalankan shell bash di container Docker yang sedang berjalan untuk digunakan Node 2.
$ docker exec -it codelab_otsim_ctnr bash
Pada perintah bash baru ini, buat proses CLI dengan argumen 2. Ini adalah perangkat Thread yang diemulasikan kedua Anda:
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 PAN ID, menggunakan nilai yang sama dengan Set Data Operasional Node 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Lakukan set data ini sebagai set data aktif:
> dataset commit active Done
Aktifkan antarmuka IPv6:
> ifconfig up Done
Operasi protokol Start Thread:
> thread start Done
Perangkat akan melakukan inisialisasi sendiri sebagai Anak. Perangkat Turunan Thread setara dengan Perangkat Akhir, yaitu perangkat Thread yang hanya mengirim dan menerima traffic unicast dengan perangkat Induk.
> state child Done
Dalam waktu 2 menit, Anda akan melihat status beralih dari child ke router. Router Thread dapat merutekan traffic antarperangkat Thread. Objek ini juga disebut sebagai Induk.
> state router Done
Memverifikasi jaringan
Cara mudah untuk memverifikasi jaringan mesh adalah dengan melihat tabel router.
1. Periksa 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 beralih 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 sebesar 0x5800 ditemukan dalam tabel, yang mengonfirmasi bahwa node tersebut terhubung ke mesh.
2. Ping Node 1 dari Node 2
Verifikasi 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 antara dua perangkat Thread yang diemulasi, uji jaringan mesh dengan meng-offline-kan satu node.
Kembali ke Node 1 dan hentikan Thread:
> thread stop Done
Beralih ke Node 2 dan periksa statusnya. Dalam waktu dua menit, Node 2 mendeteksi bahwa pemimpin (Node 1) sedang offline, dan Anda akan melihat Node 2 bertransisi 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 Docker bash. Reset ke setelan pabrik dilakukan untuk memastikan bahwa kredensial jaringan Thread yang kita gunakan dalam latihan ini tidak diteruskan ke latihan berikutnya.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Anda mungkin harus menekan enter beberapa kali untuk memunculkan kembali perintah > setelah perintah factoryreset. Jangan keluar dari container Docker.
Reset juga ke setelan pabrik dan keluar dari Node 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Lihat Referensi OpenThread CLI untuk mempelajari semua perintah CLI yang tersedia.
4. Mengautentikasi node dengan Penyiapan
Dalam latihan sebelumnya, Anda telah menyiapkan jaringan Thread dengan dua perangkat simulasi dan memverifikasi konektivitas. Namun, hal ini hanya memungkinkan traffic link-local IPv6 yang tidak diautentikasi untuk melewati antarperangkat. Untuk merutekan traffic IPv6 global di antara keduanya (dan Internet melalui router batas Thread), node harus diautentikasi.
Untuk melakukan autentikasi, satu perangkat harus bertindak sebagai Komisioner. Komisioner adalah server autentikasi yang saat ini dipilih untuk perangkat Thread baru, dan pemberi otorisasi untuk menyediakan 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, Pemimpin Thread akan bertindak sebagai Pengatur, Router Thread sebagai Penggabung.
Docker
Untuk setiap Node (jendela terminal) dalam latihan yang tersisa, pastikan Anda menjalankan container Docker dengan build OpenThread. Jika melanjutkan dari latihan sebelumnya, Anda akan tetap memiliki dua perintah bash dalam container Docker yang sama yang sudah terbuka. Jika tidak, lihat langkah Pemecahan Masalah Docker, atau cukup ulangi latihan Simulasikan jaringan Thread.
1. Membuat jaringan
Di Node 1, buat 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 Kumpulan Data Operasional baru, tetapkan 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
Lakukan set data ini sebagai set data aktif:
> dataset commit active Done
Aktifkan antarmuka IPv6:
> ifconfig up Done
Operasi protokol Start Thread:
> thread start Done
Tunggu beberapa detik, lalu verifikasi bahwa perangkat telah menjadi Pemimpin Thread:
> state leader Done
2. Memulai peran Komisioner
Saat masih berada di Node 1, mulai peran Commissioner:
> commissioner start Done
Izinkan semua Penggabung (dengan menggunakan karakter pengganti *) dengan Kredensial Penggabung J01NME untuk melakukan komisioning ke jaringan. Joiner adalah perangkat yang ditambahkan oleh administrator manusia ke Jaringan Thread yang telah diaktifkan.
> commissioner joiner add * J01NME Done
3. Memulai peran Penggabung
Di jendela terminal kedua, di penampung Docker, buat 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 di Node 2 untuk memvalidasi bahwa Node 2 kini telah bergabung ke jaringan. Dalam waktu dua menit, Node 2 bertransisi dari child ke router:
> state child Done ... > state router Done
5. Reset konfigurasi
Untuk bersiap melakukan latihan berikutnya, reset konfigurasi. Di setiap Node, hentikan Thread, 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 memunculkan kembali perintah > setelah perintah factoryreset.
5. Mengelola jaringan dengan OpenThread Daemon
Untuk latihan ini, kita akan menyimulasikan satu instance CLI (satu perangkat Thread SoC tersemat) dan satu instance Radio Co-Processor (RCP).
ot-daemon adalah mode aplikasi Posix OpenThread yang menggunakan soket UNIX sebagai input dan output, sehingga core OpenThread dapat berjalan sebagai layanan. Klien dapat berkomunikasi dengan layanan ini dengan menghubungkan 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 perintah bash dalam container Docker yang sama yang sudah terbuka. Jika tidak, lihat langkah Pemecahan Masalah Docker.
Menggunakan ot-daemon
Latihan ini akan menggunakan tiga jendela terminal, yang sesuai dengan berikut ini:
- Instance CLI perangkat Thread simulasi (Node 1)
- Proses
ot-daemon - Instance
ot-ctlCLI
1. Mulai Node 1
Di jendela terminal pertama, buat proses CLI untuk perangkat Thread yang diemulasi:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Catatan: Jika Anda tidak melihat perintah > setelah menjalankan perintah ini, tekan enter.
Buat Kumpulan Data Operasional baru, tetapkan 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
Lakukan set data ini sebagai set data aktif:
> dataset commit active Done
Aktifkan antarmuka IPv6:
> ifconfig up Done
Operasi protokol Start 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 di langkah Simulasikan jaringan Thread, satu alamat bersifat link-local (fe80) dan tiga alamat bersifat mesh-local (fd). EID adalah alamat mesh-local yang tidak berisi ff:fe00 dalam alamat. Dalam contoh output ini, EID-nya adalah fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Identifikasi EID tertentu 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—hal ini normal dan dapat diabaikan.
Mulai ot-daemon untuk node RCP, yang akan kita sebut Node 2. Gunakan flag verbose -v agar Anda dapat melihat output log dan mengonfirmasi bahwa fungsi 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 verbose 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. Menggunakan ot-ctl untuk bergabung ke jaringan
Kita belum menugaskan Node 2 (RCP ot-daemon) ke jaringan Thread mana pun. Di sinilah ot-ctl berperan. ot-ctl menggunakan CLI yang sama dengan aplikasi CLI OpenThread. Oleh karena itu, Anda dapat mengontrol node ot-daemon dengan cara yang sama seperti perangkat Thread simulasi lainnya.
Buka jendela terminal ketiga dan jalankan container yang ada:
$ docker exec -it codelab_otsim_ctnr bash
Setelah berada di dalam container, 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 bergabung ke Penggabung tertentu:
> eui64 18b4300000000001 Done
Di Node 1 (jendela terminal pertama), mulai Commissioner dan batasi bergabung hanya ke eui64 tersebut:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Di jendela terminal ketiga, aktifkan antarmuka jaringan untuk Node 2 dan gabungkan 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 Jaringan Thread.
Sekarang gabungkan Node 2 ke jaringan Thread (sekali lagi, di jendela terminal ketiga):
> thread start Done
4. Memvalidasi autentikasi jaringan
Di terminal ketiga, periksa state di Node 2 untuk memvalidasi bahwa node tersebut kini telah bergabung ke jaringan. Dalam waktu dua menit, Node 2 bertransisi dari child ke router:
> state child Done ... > state router Done
5. Memvalidasi konektivitas
Di jendela terminal ketiga, keluar dari ot-ctl menggunakan perintah Ctrl+D atau exit, lalu kembali ke konsol bash penampung. Dari konsol ini, ping Node 1, menggunakan EID-nya dengan perintah ping6. Jika instance RCP ot-daemon berhasil bergabung 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
Perintah bash, Anda mungkin perlu memeriksa apakah perintah tersebut berjalan dan memulai ulang / memasukkan kembali sesuai kebutuhan. Semua container Docker yang Anda buat dan tidak menggunakan opsi --rm akan tetap ada.
Untuk menampilkan container Docker yang sedang 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 (yang sedang berjalan dan yang 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 di output 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
Gunakan opsi --rm hanya jika Anda ingin container dihapus saat keluar dari container.
Jika penampung dihentikan (tercantum di docker ps -a, tetapi tidak di docker ps), mulai ulang:
$ 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
Error "Operation not permitted"
Jika Anda 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 menjalankan Docker dalam mode tanpa root.
7. Selamat!
Anda telah berhasil menyimulasikan jaringan Thread pertama menggunakan OpenThread. Keren!
Dalam codelab ini, Anda telah mempelajari cara:
- Memulai dan mengelola container Docker Simulasi OpenThread
- Mensimulasikan jaringan Thread
- Mengautentikasi node Thread
- Mengelola jaringan Thread dengan OpenThread Daemon
Untuk mempelajari lebih lanjut Thread dan OpenThread, pelajari referensi berikut:
- Pengantar Thread di openthread.io
- Spesifikasi Thread
- Repositori GitHub OpenThread
- Referensi CLI OpenThread
- Dukungan Docker OpenThread tambahan
Atau, coba gunakan OpenThread Border Router dalam container Docker.