1. Wprowadzenie
Wersja OpenThread opublikowana przez Google to implementacja open source protokołu sieciowego Thread. Google Nest udostępnia platformę OpenThread, by umożliwić szerszemu udostępnianiu technologii używanych w produktach Nest w celu przyspieszenia rozwoju produktów dla połączonego domu.
Specyfikacja wątku definiuje niezawodny, bezpieczny i bezemisyjny protokół komunikacyjny między urządzeniami z wykorzystaniem protokołu IPv6. OpenThread implementuje wszystkie warstwy sieci Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, łączeniem sieci typu mesh i routingiem sieci typu mesh.
Dzięki nim dowiesz się, jak symulować sieć Thread... na urządzeniach emulowanych przy użyciu Dockera.
Czego się nauczysz
- Konfigurowanie łańcucha kompilacji OpenThread
- Jak symulować sieć Thread
- Jak uwierzytelniać węzły wątków
- Jak zarządzać siecią Thread za pomocą demona OpenThread
Czego potrzebujesz
- Docker
- Podstawowa wiedza o Linuksie, routingu sieci
2. Skonfiguruj Dockera
Dzięki nim dowiesz się, jak używać Dockera na komputerze z systemem Linux, macOS X lub Windows. Zalecanym środowiskiem jest Linux.
Zainstaluj Dockera
Zainstaluj Dockera w wybranym systemie operacyjnym.
Pociągnij obraz Dockera
Po zainstalowaniu Dockera otwórz okno terminala i pociągnij obraz Dockera openthread/environment. Ten obraz korzysta z demonów OpenThread i OpenThread, które są gotowe do użycia w ramach tego ćwiczenia z programowania.
$ docker pull openthread/environment:latest
Pełne pobieranie może potrwać kilka minut.
W oknie terminala uruchom kontener Dockera na obrazie i połącz się z jego powłoką bash:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
Flagi wymagane na potrzeby tego ćwiczenia z programowania:
--sysctl net.ipv6.conf.all.disable_ipv6=0– włącza IPv6 w kontenerze--cap-add=net_admin– umożliwia korzystanie z funkcji NET_ADMIN, która umożliwia wykonywanie operacji związanych z siecią, takich jak dodawanie tras IP
W kontenerze powinno pojawić się powiadomienie podobne do tego:
root@c0f3912a74ff:/#
W powyższym przykładzie c0f3912a74ff to identyfikator kontenera. Identyfikator kontenera kontenera Dockera różni się od identyfikatora wyświetlanego w wierszach poleceń tego ćwiczenia z programowania.
Korzystanie z Dockera
Ćwiczenia z programowania zakładają, że znasz podstawy korzystania z Dockera. W środowisku programistycznym należy pozostawać w kontenerze Dockera.
3. Symulowanie sieci typu Thread
Przykładowa aplikacja, której użyjesz na potrzeby tego ćwiczeń z programowania, pokazuje minimalną liczbę aplikacji OpenThread, które udostępniają interfejsy OpenThread konfiguracji i zarządzania nimi za pomocą podstawowego interfejsu wiersza poleceń.
To ćwiczenie wymaga wykonania tylko kilku minimalnych kroków – emulacji jednego urządzenia z wątkiem z innego emulowanego urządzenia Thread.
Poniższa ilustracja przedstawia podstawową topologię sieci Thread. W tym ćwiczeniu będziemy emulować 2 węzły w zielonym kółku: lider wątku i router wątków z jednym połączeniem między nimi.
Utwórz sieć
1. Start Node 1
Jeśli nie zostało to jeszcze zrobione, w oknie terminala uruchom kontener Dockera i połącz się z jego powłoką bash:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
W kontenerze Dockera utwórz proces wiersza poleceń dla emulowanego urządzenia Thread za pomocą pliku binarnego ot-cli-ftd.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz komunikatu >, naciśnij enter.
Ten plik binarny implementuje urządzenie OpenThread. Sterownik radiowy IEEE 802.15.4 jest wdrażany poza UDP (ramki IEEE 802.15.4 są przekazywane w ładunkach UDP).
Argument 1 to deskryptor pliku reprezentujący najmniej istotne bity &przypisane przez fabrykę i IEEE EUI-64 dla emulowanego urządzenia. Ta wartość jest także używana podczas wiązania z portem UDP dla emulacji radiowej IEEE 802.15.4 (port = 9000 + deskryptor pliku). Każde wystąpienie emulowanego urządzenia Thread w tym ćwiczeniu z programowania będzie korzystać z innego deskryptora pliku.
Uwaga: podczas tworzenia procesu emulowanego urządzenia używaj tylko deskryptorów plików o wartości 1 lub większej, jak zaznaczono w tym ćwiczeniu z programowania. Deskryptor pliku 0 jest zarezerwowany do innego użytku.
Utwórz nowy zbiór danych operacyjnych i zatwierdź go jako aktywny. Zbiór danych operacyjnych to konfiguracja tworzonej sieci 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
Prześlij ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Uruchom operację protokołu Thread:
> thread start Done
Poczekaj kilka sekund i sprawdź, czy urządzenie stał się liderem wątku. Lider jest urządzeniem odpowiedzialnym za zarządzanie przypisywaniem identyfikatorów routera.
> state leader Done
Wyświetl adresy IPv6 przypisane do interfejsu węzła Thread 1's (Twoje dane wyjściowe będą różne):
> 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
Zwróć uwagę na konkretne typy adresów IPv6:
- Zaczyna się od
fd= mesh-local - Zaczyna się od
fe80= link-local
Typy adresów lokalnych sieci typu mesh są dodatkowo klasyfikowane:
- Zawiera:
ff:fe00= lokalizator routera (RLOC) - Nie zawiera
ff:fe00= identyfikator punktu końcowego (EID)
Znajdź identyfikator EID w danych wyjściowych w konsoli i zanotuj go na później. W tym przykładzie identyfikator EID wygląda tak:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Start Node 2
Otwórz nowy terminal i uruchom powłokę bash w działającym obecnie kontenerze Dockera, aby użyć go dla węzła 2.
$ docker exec -it codelab_otsim_ctnr bash
W nowym wierszu operatora bash utwórz proces interfejsu wiersza poleceń z argumentem 2. Oto drugie emulowane urządzenie Thread:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz komunikatu >, naciśnij enter.
Skonfiguruj klucz sieci Thread i identyfikator PAN przy użyciu tych samych wartości operacyjnych, co zbiór danych 1 i 39:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Prześlij ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Uruchom operację protokołu Thread:
> thread start Done
Urządzenie zainicjuje się jako dziecko. Podrzędny element wątku jest odpowiednikiem urządzenia końcowego, które jest przeznaczone do przesyłania i odbierania ruchu tylko w przypadku urządzenia nadrzędnego.
> state child Done
W ciągu 2 minut powinien zmienić się stan z child na router. Router Thread umożliwia przenoszenie ruchu między urządzeniami z wątkami. Określa się go również jako podmiot nadrzędny.
> state router Done
Weryfikowanie sieci
Łatwą metodą weryfikacji sieci typu mesh jest obserwowanie tabeli routera.
1. Sprawdź połączenie
W węźle 2 pobierz RLOC16. RLOC16 to ostatnie 16 bitów adresu IPv6 urządzenia.
> rloc16 5800 Done
W węźle 1 sprawdź tabelę routera dla węzła 2' RLOC16. Najpierw sprawdź, czy węzeł 2 przełączył się na stan routera.
> 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 |
W tabeli znaleziono węzeł RLOC o wartości 0x5800 węzła 2, potwierdzając połączenie z siatką.
2. Ping – węzeł 1 z węzła 2
Zweryfikuj połączenie między 2 emulowanymi urządzeniami Thread. W węźle 2 pingidentyfikator EID przypisany do węzła 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
Naciśnij enter, aby wrócić do wiersza poleceń >.
Testowanie sieci
Teraz, gdy możesz wysłać ping do 2 emulowanych urządzeń Thread, przetestuj sieć typu mesh, przełączając jeden węzeł w tryb offline.
Wróć do węzła 1 i zatrzymaj wątek:
> thread stop Done
Przełącz się na węzeł 2 i sprawdź stan. W ciągu 2 minut węzeł 2 wykrywa, że replika lidera (węzła 1) jest offline i powinien być widoczny węzeł 2 jako leader sieci:
> state router Done ... > state leader Done
Po potwierdzeniu zatrzymaj węzeł Thread i ustawienia fabryczne – węzeł 2, zanim wrócisz do okna Dockera bash. Trwa reset fabryczny, aby dane logowania do sieci typu Thread używane w tym ćwiczeniu nie zostały przeniesione do następnego ćwiczenia.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Być może trzeba będzie nacisnąć kilka razy enter, aby wyświetlić polecenie > po poleceniu factoryreset. Nie zamykaj kontenera Dockera.
Poza tym przywróć ustawienia fabryczne i zamknij węzeł 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Wszystkie dostępne polecenia wiersza poleceń znajdziesz w dokumentacji wiersza poleceń OpenThread.
4. Uwierzytelnianie węzłów za pomocą prowizji
W poprzednim ćwiczeniu konfigurujesz sieć Thread z 2 symulowanymi urządzeniami i zweryfikowanym połączeniem. Pozwala to jednak przekazywać tylko nieuwierzytelniony lokalny ruch IPv6 linku. Aby kierować globalny ruch IPv6 między nimi (i z internetu za pomocą routera obramowania Thread), węzły muszą być uwierzytelnione.
Aby się uwierzytelnić, jedno urządzenie musi działać jako komisarz. Narzędzie Commissioner jest obecnie wybranym serwerem uwierzytelniania w przypadku nowych urządzeń Thread i autoryzacją podawania danych logowania do sieci wymaganych przez urządzenia do dołączania do sieci.
W tym ćwiczeniu użyjemy tej samej topologii dwóch węzłów. Aby przeprowadzić uwierzytelnianie, osoba kierująca wątekem będzie pełnić funkcję komisarza, czyli routera nici jako pomocnika.
Docker
W przypadku każdego węzła (okna terminala) w pozostałych ćwiczeniach sprawdź, czy uruchamiasz kontener Dockera za pomocą kompilacji OpenThread. W przypadku kontynuacji poprzedniego ćwiczenia w tym samym kontenerze Dockera powinny znajdować się jeszcze 2 potwierdzenia typu bash. Jeśli nie, zobacz krok Rozwiązywanie problemów z Dockerem lub po prostu powtórz ćwiczenie Symuluj sieć wątków.
1. Utworzenie sieci
W węźle 1 utwórz proces wiersza poleceń:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz komunikatu >, naciśnij enter.
Utwórz nowy zbiór danych operacyjnych, zatwierdź go jako aktywny i uruchom wątek:
> 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
Prześlij ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Uruchom operację protokołu Thread:
> thread start Done
Poczekaj kilka sekund i sprawdź, czy urządzenie zostało liderem w wątku:
> state leader Done
2. Rozpoczynanie roli komisarza
Nie opuszczając węzła 1, uruchom rolę Komisarz:
> commissioner start Done
Zezwalaj na dołączanie dowolną osobę (z użyciem symbolu wieloznacznego *) z danymi uwierzytelniającymi usługi J01NME do wykonywania prowizji w sieci. Łącznik to urządzenie dodane przez administratora do zleconych sieci Thread Network.
> commissioner joiner add * J01NME Done
3. Rozpoczynanie roli złącza
W drugim oknie terminala w kontenerze Dockera pojawia się nowy proces interfejsu wiersza poleceń. To jest węzeł 2.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
W węźle 2 włącz rolę Złącznika za pomocą danych uwierzytelniających J01NME.
> ifconfig up Done > joiner start J01NME Done
... poczekaj kilka sekund na potwierdzenie ...
Join success
Jako urządzenie łączące urządzenie (węzeł 2) uwierzytelniło się za pomocą narzędzia Commissioner (Node 1) i otrzymało dane logowania do sieci Thread.
Po uwierzytelnieniu węzła 2 uruchom wątek:
> thread start Done
4. Weryfikowanie uwierzytelniania sieci
Sprawdź węzeł state w węźle 2, aby potwierdzić, że przyłączył się on do sieci. W ciągu 2 minut węzeł 2 zostanie przeniesiony z child do router:
> state child Done ... > state router Done
5. Resetuj konfigurację
Aby przygotować się do kolejnego ćwiczenia, zresetuj konfigurację. W każdym węźle wyłącz Thread, przywróć ustawienia fabryczne i zamknij emulowane urządzenie Thread:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Być może trzeba będzie nacisnąć kilka razy enter, aby wyświetlić polecenie > po poleceniu factoryreset.
5. Zarządzanie siecią za pomocą demona OpenThread
W tym ćwiczeniu zasymulujemy 1 instancję wiersza poleceń (pojedyncze urządzenie umieszczone w wątku SoC) i 1 instancję Radio-CosProcesor (RCP).
ot-daemon to tryb aplikacji OpenThread Posix, który korzysta z gniazdka UNIX jako danych wejściowych, by można było uruchomić ją jako usługę. Klient może komunikować się z tą usługą przez połączenie się z gniazdem za pomocą interfejsu wiersza poleceń OpenThread.
ot-ctl to interfejs wiersza poleceń udostępniany przez platformę ot-daemon w celu zarządzania RCP i konfigurowaniem go. W ten sposób połączysz RCP z siecią utworzoną przez urządzenie Thread.
Docker
W przypadku każdego węzła (okna terminala) tego ćwiczenia upewnij się, że korzystasz z kontenera Dockera razem z kompilacją OpenThread. Jeśli przejdziesz do poprzedniego ćwiczenia, w tym samym kontenerze Dockera powinny pojawić się 2 potwierdzenia typu bash. Jeśli tak nie jest, zobacz krok Rozwiązywanie problemów z Dockerem.
Używaj demona ot
To ćwiczenie będzie obejmować 3 okna terminala odpowiadające tym:
- Instancja wiersza poleceń symulowanego urządzenia Thread (węzeł 1)
- Proces
ot-daemon ot-ctlinstancja wiersza poleceń
1. Start Node 1
W pierwszym oknie terminala uruchom interfejs wiersza poleceń dla emulowanego urządzenia Thread:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz komunikatu >, naciśnij enter.
Utwórz nowy zbiór danych operacyjnych, zatwierdź go jako aktywny i uruchom wątek:
> 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
Prześlij ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Uruchom operację protokołu Thread:
> thread start Done
Wyświetl adresy IPv6 przypisane do interfejsu węzła 1 i 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 >
Zgodnie z informacjami w kroku Symuluj sieć wątków jeden adres to lokalny link (fe80), a 3 – lokalny mesh (fd). Identyfikator EID to adres lokalny typu mesh, który nie zawiera adresu ff:fe00. W tym przykładowym wyniku identyfikator EID to fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Określ identyfikator EID z danych wyjściowych interfejsu ipaddr, który będzie używany do komunikacji z węzłami.
2. Zacznij demon
W 2 oknie terminala utwórz węzeł urządzenia tun i ustaw uprawnienia do zapisu i odczytu:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
To urządzenie jest używane do przesyłania i odbierania pakietów na urządzeniach wirtualnych. Jeśli urządzenie zostało już utworzone, może pojawić się błąd – to normalne i można je zignorować.
Uruchom ot-daemon dla węzła RCP, który wywołamy Węzeł 2. Użyj flagi szczegółowej -v, aby zobaczyć dane wyjściowe logu i potwierdzić, że działa:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \ 'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'
Jeśli operacja się uda, ot-daemon w trybie szczegółowym wygeneruje dane wyjściowe podobne do tych:
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
Pozostaw ten terminal otwarty i aktywny w tle. Nie będziemy wprowadzać do niego kolejnych poleceń.
3. Dołącz do sieci za pomocą polecenia OT-CTL
Nie zleciliśmy jeszcze węzła 2 (ot-daemon RCP) w dowolnej sieci Thread. Tutaj pojawi się ot-ctl. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja OpenThread CLI. Dlatego możesz kontrolować węzły ot-daemon w taki sam sposób jak inne symulowane urządzenia Thread.
Otwórz trzecie okno terminala i wykonaj istniejący kontener:
$ docker exec -it codelab_otsim_ctnr bash
W kontenerze uruchom polecenie ot-ctl:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
Do zarządzania węzłem 2 (węzłem RCP) rozpoczętym w drugim oknie terminalu ot-daemon użyjesz ot-ctl. Sprawdź state węzła 2:
> state disabled Done
Pobierz węzeł eui64 2 i 3, aby ograniczyć dołączanie do określonego łącznika:
> eui64 18b4300000000001 Done
W węźle 1 (pierwszym oknie terminala) uruchom inspektora i ogranicz go tylko do eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
W trzecim oknie terminala wyświetl interfejs sieci węzła 2 i dołącz do sieci:
> ifconfig up Done > joiner start J01NME Done
... poczekaj kilka sekund na potwierdzenie ...
Join success
Jako połączenie, w tym protokołu RCP (węzła 2), udało się uwierzytelnić za pomocą komisarza (węzła 1) i otrzymało dane logowania do sieci typu Thread.
Teraz połącz węzeł 2 z siecią Thread (ponownie w 3. oknie terminala):
> thread start Done
4. Weryfikowanie uwierzytelniania sieci
W trzecim terminalu sprawdź state w węźle 2, aby się upewnić, że przyłączył się on do sieci. W ciągu 2 minut węzeł 2 zostanie przeniesiony z child do router:
> state child Done ... > state router Done
5. Weryfikowanie połączeń
W trzecim terminalu zakończ działanie aplikacji ot-ctl za pomocą polecenia Ctrl+D lub exit i wróć do konsoli bash kontenera. W tej konsoli możesz wysyłać pingi do węzła 1, używając jego identyfikatora EID z poleceniem ping6. Jeśli instancja RCP ot-daemon zostanie połączona i połączy się z siecią Thread, uda się wysłać ping:
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. Rozwiązywanie problemów z Dockerem
Jeśli został zamknięty kontener Dockera
bash potwierdzenia. Może być konieczne sprawdzenie, czy kod jest uruchomiony oraz ponowne uruchomienie / ponowne uruchomienie w razie potrzeby.
Aby sprawdzić, które kontenery Dockera są uruchomione:
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Aby wyświetlić wszystkie kontenery Dockera (zarówno aktywne, jak i zatrzymane):
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Jeśli w danych wyjściowych polecenia docker ps nie widzisz kontenera codelab_otsim_ctnr, uruchom go ponownie:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
Jeśli kontener jest zatrzymany (wymieniony na liście docker ps -a, ale nie docker ps), uruchom go ponownie:
$ docker start -i codelab_otsim_ctnr
Jeśli kontener Dockera jest już uruchomiony (wymieniony w tabeli docker ps), połącz się z nim ponownie w każdym terminalu:
$ docker exec -it codelab_otsim_ctnr bash
"Błędy niedozwolone
Jeśli podczas tworzenia nowych węzłów OpenThread (przy użyciu polecenia mknod) wystąpią błędy Operation not permitted, upewnij się, że uruchomiono Docker jako użytkownik główny zgodnie z poleceniami zawartymi w tym ćwiczeniu z programowania. To ćwiczenie nie obsługuje uruchamiania Dockera w trybie bez roota.
7. Gratulacje!
Udało Ci się zasymulować pierwszą sieć Thread za pomocą OpenThread. Świetnie!
Dzięki nim dowiesz się, jak:
- Uruchamianie kontenera Dockera symulacji OpenThread i zarządzanie nim
- Symulowanie sieci typu Thread
- Uwierzytelnianie węzłów wątku
- Zarządzanie siecią Thread za pomocą demona OpenThread
Więcej informacji o Thread i OpenThread znajdziesz w tych artykułach:
- Wprowadzenie do wątku na forum openthread.io
- Specyfikacja wątku
- Repozytorium OpenThread na GitHubie
- Dokumentacja wiersza poleceń OpenThread
- Dodatkowa obsługa Dockera OpenThread
Możesz też spróbować użyć routera OpenThread Border w kontenerze Dockera.