1. Wprowadzenie
Opublikowana przez Google implementacja OpenThread to implementacja protokołu sieciowego Thread typu open source. Firma Google Nest udostępniła rozwiązanie OpenThread, aby udostępnić deweloperom technologię wykorzystywaną w produktach Nest i przyspieszyć proces opracowywania produktów do domów inteligentnych.
Specyfikacja Thread definiuje oparty na protokole IPv6 niezawodny, bezpieczny i oszczędny, bezprzewodowy protokół komunikacyjny między urządzeniami domowymi. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem linku mesh i routingiem sieci typu mesh.
Dzięki temu ćwiczeniu w Codelabs dowiesz się, jak symulować sieć Thread na emulowanych urządzeniach przy użyciu Dockera.
Czego się nauczysz
- Jak skonfigurować łańcuch narzędzi do kompilacji OpenThread
- Jak symulować sieć Thread
- Jak uwierzytelniać węzły Thread
- Jak zarządzać siecią Thread przy użyciu OpenThread Daemon
Czego potrzebujesz
- Docker
- Podstawowa znajomość systemu Linux i routingu sieci
2. Konfigurowanie Dockera
Celem tych ćwiczeń w Codelabs jest używanie Dockera na komputerze z systemem Linux, Mac OS X lub Windows. Zalecanym środowiskiem jest Linux.
Zainstaluj Dockera
Zainstaluj Dockera w wybranym systemie operacyjnym.
Pobieranie obrazu Dockera
Po zainstalowaniu Dockera otwórz okno terminala i pobierz obraz Dockera openthread/environment. Ten obraz przedstawia gotowe rozwiązania OpenThread i OpenThread Daemon do wykorzystania w tym ćwiczeniach z programowania.
$ docker pull openthread/environment:latest
Pamiętaj, że całkowite pobranie może potrwać kilka minut.
W oknie terminala uruchom kontener Dockera z obrazu 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
Opcja --rm usuwa kontener, gdy wyjdziesz z niego. Nie używaj tej opcji, jeśli nie chcesz usunąć kontenera.
Zwróć uwagę na flagi, które są wymagane w tym ćwiczeniu z programowania:
--sysctl net.ipv6.conf.all.disable_ipv6=0– włącza protokół IPv6 w kontenerze.--cap-add=net_admin– włącza funkcję NET_ADMIN, która umożliwia wykonywanie operacji związanych z siecią, takich jak dodawanie tras IP
W kontenerze powinien wyświetlić się prompt podobny do tego:
root@c0f3912a74ff:/#
W tym przykładzie c0f3912a74ff to identyfikator kontenera. Identyfikator kontenera Dockera będzie się różnić od identyfikatora widocznego w promptach dotyczących tego ćwiczenia z programowania.
Korzystanie z Dockera
W tym ćwiczeniu w Codelabs zakładamy, że znasz podstawy korzystania z Dockera. W trakcie ćwiczeń z programowania musisz pozostać w kontenerze Dockera.
3. Symulowanie sieci Thread
Przykładowa aplikacja, której użyjesz w tym module Codelab, przedstawia minimalną aplikację OpenThread, która udostępnia interfejsy konfiguracji i zarządzania OpenThread za pomocą podstawowego interfejsu wiersza poleceń (CLI).
To ćwiczenie przedstawia minimalne kroki wymagane do wysłania pingu jednego emulowanego urządzenia Thread z innego emulowanego urządzenia Thread.
Poniższy rysunek przedstawia podstawową topologię sieci Thread. W tym ćwiczeniu emulujemy 2 węzły znajdujące się w zielonym kółku: węzeł wiodący i router wątków z jednym połączeniem między nimi.
Tworzenie sieci
1. Uruchom węzeł 1
Jeśli jeszcze nie masz tego za sobą, uruchom kontener Dockera w oknie terminala 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 interfejsu wiersza poleceń dla emulowanego urządzenia Thread przy użyciu 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 znaku >, naciśnij enter.
Ten plik binarny implementuje urządzenie OpenThread. Sterownik radiowy IEEE 802.15.4 jest zaimplementowany razem z UDP (ramki IEEE 802.15.4 są przekazywane w ładunkach UDP).
Argument funkcji 1 to deskryptor pliku, który reprezentuje najmniej istotne informacje z „przypisanego fabrycznie” IEEE EUI-64 dla emulowanego urządzenia. Ta wartość jest też używana podczas wiązania z portem UDP na potrzeby emulacji radiowej IEEE 802.15.4 (port = 9000 + deskryptor pliku). Każde wystąpienie emulowanego urządzenia Thread w tym ćwiczeniach z programowania będzie używać innego deskryptora pliku.
Uwaga: podczas uruchamiania procesu na emulowanym urządzeniu używaj deskryptorów plików o wartości 1 lub większej, jak podano w tym ćwiczeniu z programowania. Deskryptor pliku 0 jest zarezerwowany do innego zastosowania.
Utwórz nowy operacyjny zbiór danych i zatwierdź go jako aktywny. Działający zbiór danych 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
Zatwierdź ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Rozpoczynanie operacji protokołu Thread:
> thread start Done
Poczekaj kilka sekund i sprawdź, czy urządzenie jest liderem wątku. Lider to urządzenie odpowiedzialne za zarządzanie przypisywaniem identyfikatora routera.
> state leader Done
Wyświetl adresy IPv6 przypisane do interfejsu Thread węzła 1 (dane wyjściowe będą inne):
> 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= sieci typu mesh-local - Zaczyna się od
fe80= link-local
Typy adresów lokalnych sieci typu mesh są klasyfikowane dalej:
- Zawiera
ff:fe00= lokalizator routera (RLOC) - Nie zawiera identyfikatora punktu końcowego (
ff:fe00) = identyfikatora punktu końcowego (EID)
Zidentyfikuj EID w danych wyjściowych konsoli, zapisz go do późniejszego użycia. W przykładowych danych wyjściowych powyżej identyfikator EID to:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Uruchamianie węzła 2
Otwórz nowy terminal i uruchom powłokę bash w obecnie uruchomionym kontenerze Dockera, aby użyć jej w Node. 2.
$ docker exec -it codelab_otsim_ctnr bash
W nowym promptie bash utwórz proces interfejsu wiersza poleceń z argumentem 2. To Twoje 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 znaku >, naciśnij enter.
Skonfiguruj klucz sieciowy wątku i identyfikator PAN, używając tych samych wartości co w zbiorze danych operacyjnych węzła 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Zatwierdź ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Rozpoczynanie operacji protokołu Thread:
> thread start Done
Urządzenie uruchomi się jako dziecko. Element podrzędny Thread jest odpowiednikiem urządzenia końcowego Thread, które przesyła i odbiera ruch pojedynczy wyłącznie na urządzeniu rodzica.
> state child Done
W ciągu 2 minut stan powinien się zmienić z child na router. Router Thread może kierować ruch między urządzeniami Thread. Nazywa się go też elementem nadrzędnym.
> state router Done
Sprawdzanie sieci
Łatwym sposobem na sprawdzenie sieci typu mesh jest sprawdzenie tabeli routera.
1. Sprawdź połączenie
W węźle Node 2 pobierz RLOC16. RLOC16 to ostatnie 16 bitów adresu IPv6 RLOC urządzenia.
> rloc16 5800 Done
W węźle 1 sprawdź w tabeli routerów wartość RLOC16 węzła. Upewnij się, że Node 2 przełączy się najpierw na router.
> 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 znajduje się wartość RLOC węzła 2 wynosząca 0x5800, co potwierdza, że jest on połączony z siatką.
2. Pingowanie węzła Node 1 z Node 2
Sprawdź połączenie między 2 emulowanymi urządzeniami Thread. W węźle ping identyfikator 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 promptu interfejsu wiersza poleceń >.
Testowanie sieci
Możesz już wysyłać pingi między 2 emulowanymi urządzeniami Thread, więc przetestuj sieć typu mesh, przełączając 1 węzeł w tryb offline.
Wróć do węzła 1 i zatrzymaj Thread:
> thread stop Done
Przełącz się na węzeł 2 i sprawdź stan. W ciągu 2 minut Node 2 wykryje, że najlepszy wariant (węzeł 1) jest offline, i powinien przełączyć się na węzeł 2 jako leader sieci:
> state router Done ... > state leader Done
Po potwierdzeniu zatrzymaj Thread i przywróć w Node 2 ustawienia fabryczne, zanim wrócisz do promptu bash Dockera. Przeprowadzamy przywrócenie do ustawień fabrycznych, aby mieć pewność, że dane logowania do sieci Thread, które użyliśmy w tym ćwiczeniu, nie zostaną przeniesione do następnego ćwiczenia.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Konieczne może być kilkukrotne naciśnięcie enter, aby przywrócić wiersz > po poleceniu factoryreset. Nie zamykaj kontenera Dockera.
Oprócz tego przywróć urządzenie do ustawień fabrycznych i zamknij węzeł 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Zapoznaj się z dokumentacją interfejsu wiersza poleceń OpenThread, aby poznać wszystkie dostępne polecenia interfejsu wiersza poleceń.
4. Uwierzytelnianie węzłów za pomocą przekazywania
W poprzednim ćwiczeniu udało Ci się skonfigurować sieć Thread z 2 symulowanymi urządzeniami i zweryfikowanymi połączeniami. Pozwala to jednak przesyłać między urządzeniami tylko nieuwierzytelniony ruch związany z lokalnym połączeniem IPv6. Aby można było kierować globalny ruch IPv6 między nimi (a internetem przez router graniczny Thread), węzły muszą być uwierzytelnione.
Aby można było dokonać uwierzytelnienia, jedno urządzenie musi działać jako komisarz. Komisarz to obecnie wybierany serwer uwierzytelniania dla nowych urządzeń Thread i autoryzacja do podawania danych logowania do sieci, które są wymagane, by urządzenia mogły połączyć się z siecią.
W tym ćwiczeniu użyjemy tej samej topologii dwóch węzłów co poprzednio. W przypadku uwierzytelniania lider Thread będzie pełnił rolę komisarza, a router wątków – łącznik.
Docker
W każdym węźle (oknie terminala) w pozostałych ćwiczeniach sprawdź, czy masz uruchomiony kontener Dockera z kompilacją OpenThread. Jeśli chcesz kontynuować poprzednie ćwiczenie, w tym samym kontenerze Dockera powinny być już otwarte 2 prompty bash. Jeśli nie, przejdź do kroku Rozwiązywanie problemów z Dockerem lub po prostu ponownie wykonaj ćwiczenie Symuluj sieć Thread.
1. Utwórz sieć
W węźle 1 utwórz proces interfejsu wiersza poleceń:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz znaku >, naciśnij enter.
Utwórz nowy operacyjny zbiór danych, zatwierdź go jako aktywny i uruchom 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
Zatwierdź ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Rozpoczynanie operacji protokołu Thread:
> thread start Done
Poczekaj kilka sekund i sprawdź, czy urządzenie jest liderem wątku:
> state leader Done
2. Nadanie roli komisarza
Nie wychodząc z węzła 1, rozpocznij rolę komisarza:
> commissioner start Done
Zezwól dowolnemu Joinerowi (korzystając z symbolu wieloznacznego *) z danymi logowania łączenia kont J01NME na prowizje w sieci. Łącznik to urządzenie dodawane przez administratora do zamówionej sieci Thread.
> commissioner joiner add * J01NME Done
3. Rozpoczynanie roli Łącznik
W drugim oknie terminala w kontenerze Dockera utwórz nowy proces interfejsu wiersza poleceń. To jest Node 2.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
W węźle Node 2 włącz rolę łączenia za pomocą danych logowania łączenia J01NME.
> ifconfig up Done > joiner start J01NME Done
... odczekaj kilka sekund na potwierdzenie ...
Join success
W ramach łączenia urządzenie (węzeł 2) uwierzytelniło się za pomocą komisarza (węzeł 1) i otrzymało dane logowania do sieci Thread.
Teraz gdy Node 2 jest uwierzytelniony, uruchom Thread:
> thread start Done
4. Weryfikowanie uwierzytelniania sieci
Sprawdź interfejs state w węźle 2, aby upewnić się, że połączył się on z siecią. W ciągu dwóch minut węzeł 2 przełącza się z child na router:
> state child Done ... > state router Done
5. Resetuj konfigurację
Aby przygotować się do następnego ćwiczenia, zresetuj konfigurację. W każdym węźle zatrzymaj aplikację Thread, przywróć ją do ustawień fabrycznych i zamknij emulowane urządzenie Thread:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Konieczne może być kilkukrotne naciśnięcie enter, aby przywrócić wiersz > po poleceniu factoryreset.
5. Zarządzanie siecią za pomocą OpenThread Daemon
W tym ćwiczeniu symulujemy 1 instancję interfejsu wiersza poleceń (pojedyncze osadzone urządzenie SoC Thread) i 1 instancję koprocesora radiowego (RCP).
ot-daemon to tryb aplikacji OpenThread Posix, który jako dane wejściowe i wyjściowe wykorzystuje gniazdo UNIX, dzięki czemu Core OpenThread może działać jako usługa. Klient może komunikować się z tą usługą, łącząc się z gniazdem za pomocą interfejsu wiersza poleceń OpenThread jako protokołu.
ot-ctl to interfejs wiersza poleceń udostępniany przez usługę ot-daemon, który służy do zarządzania RCP i jego konfigurowania. Za jego pomocą połączymy RCP z siecią utworzoną przez urządzenie Thread.
Docker
W każdym węźle (oknie terminala) w tym ćwiczeniu sprawdź, czy masz uruchomiony kontener Dockera z kompilacją OpenThread. Jeśli chcesz kontynuować poprzednie ćwiczenie, w tym samym kontenerze Dockera powinny być już otwarte 2 prompty bash. Jeśli nie, przejdź do kroku Rozwiązywanie problemów z Dockerem.
Użyj polecenia ot-daemon
W tym ćwiczeniu będą używane 3 okna terminala, odpowiadające tym:
- Instancja interfejsu wiersza poleceń symulowanego urządzenia Thread (węzeł 1)
- Proces usługi
ot-daemon ot-ctlinstancja interfejsu wiersza poleceń
1. Uruchom węzeł 1
W pierwszym oknie terminala utwórz proces interfejsu 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 znaku >, naciśnij enter.
Utwórz nowy operacyjny zbiór danych, zatwierdź go jako aktywny i uruchom 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
Zatwierdź ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Rozpoczynanie operacji protokołu Thread:
> thread start Done
Wyświetl adresy IPv6 przypisane do interfejsu Thread węzła 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 >
Jak wyjaśniliśmy w kroku Symuluj sieć Thread, 1 adres ma połączenie lokalne (fe80), a 3 to sieć typu mesh (fd). Identyfikator EID to lokalny adres sieci typu mesh, który nie zawiera fragmentu ff:fe00. W tych przykładowych danych wyjściowych identyfikator EID ma wartość fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Określ konkretny EID na podstawie danych wyjściowych ipaddr, który będzie używany do komunikacji z węzłem.
2. Uruchom demona
W drugim oknie terminala utwórz węzeł urządzenia tun i ustaw uprawnienia do odczytu i zapisu:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
To urządzenie służy 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 będziemy nazywać Node 2. Użyj flagi szczegółowej -v, aby wyświetlić dane wyjściowe dziennika i sprawdzić, czy są uruchomione:
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 generuje 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 terminal otwarty i uruchomiony w tle. Nie będzie w nim kolejnych poleceń.
3. Użyj ot-ctl, by dołączyć do sieci
Nie zleciliśmy jeszcze węzła 2 (RCP ot-daemon) żadnej sieci Thread. Właśnie tutaj do akcji wkracza usługa ot-ctl. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja interfejsu wiersza poleceń OpenThread. Dlatego możesz sterować ot-daemon węzłami w taki sam sposób jak w przypadku innych symulowanych urządzeń Thread.
Otwórz trzecie okno terminala i uruchom istniejący kontener:
$ docker exec -it codelab_otsim_ctnr bash
Po otwarciu kontenera uruchom ot-ctl:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
Użyjesz ot-ctl w tym trzecim oknie terminala do zarządzania węzłem 2 (węzłem RCP), który został uruchomiony w drugim oknie terminala przy użyciu ot-daemon. Sprawdź state w węźle Node 2:
> state disabled Done
Pobierz eui64 w Node.2, aby ograniczyć możliwość dołączania do konkretnego łącznika:
> eui64 18b4300000000001 Done
W węźle 1 (pierwsze okno terminala) uruchom komisarza i ogranicz łączenie tylko do tego węzła (eui64):
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
W trzecim oknie terminala otwórz interfejs sieci węzła węzła i połącz się z siecią:
> ifconfig up Done > joiner start J01NME Done
... odczekaj kilka sekund na potwierdzenie ...
Join success
Jako łącznik RCP (Node 2) uwierzytelnił się u komisarza (węzeł 1) i otrzymał dane logowania do sieci 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ź pole state na węźle 2, aby upewnić się, że udało się połączyć z siecią. W ciągu dwóch minut węzeł 2 przełącza się z child na router:
> state child Done ... > state router Done
5. Zweryfikuj połączenia
W trzecim oknie terminala zamknij ot-ctl przy użyciu polecenia Ctrl+D lub exit i wróć do konsoli bash kontenera. Z tej konsoli wyślij ping do węzła 1, używając jego identyfikatora EID za pomocą polecenia ping6. Jeśli instancja RCP ot-daemon zostanie połączona z siecią Thread i komunikuje się z nią, ping zakończy się powodzeniem:
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 zamkniesz kontener Dockera
bash, konieczne może być sprawdzenie, czy aplikacja się uruchomiła. W razie potrzeby uruchom ją ponownie lub uruchom ponownie. Wszystkie utworzone przez Ciebie kontenery Dockera, w których nie użyto opcji --rm, powinny nadal istnieć.
Aby zobaczyć, 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 (działające 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 nie widzisz kontenera codelab_otsim_ctnr w danych wyjściowych któregoś z polecenia docker ps, 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
Opcji --rm używaj tylko wtedy, gdy chcesz, aby kontener był usuwany po zamknięciu kontenera.
Jeśli kontener został zatrzymany (wymieniony w regionie docker ps -a, ale nie docker ps), uruchom go ponownie:
$ docker start -i codelab_otsim_ctnr
Jeśli kontener Dockera (wymieniony w docker ps) jest już uruchomiony, połącz się z nim ponownie w każdym terminalu:
$ docker exec -it codelab_otsim_ctnr bash
„Operacja niedozwolona” błędy
Jeśli podczas tworzenia nowych węzłów OpenThread (za pomocą polecenia mknod) wystąpią błędy Operation not permitted, sprawdź, czy korzystasz z Dockera jako użytkownik główny zgodnie z poleceniami podanymi w tym ćwiczeniach z programowania. Te ćwiczenia w Codelabs nie obsługują uruchamiania Dockera w trybie bez roota.
7. Gratulacje!
Udało Ci się symulować pierwszą sieć Thread przy użyciu OpenThread. Świetnie!
Dzięki temu ćwiczeniu z programowania omówiliśmy, jak:
- Uruchamianie kontenera Dockera symulacyjnego OpenThread i zarządzanie nim
- Symulowanie sieci Thread
- Uwierzytelnianie węzłów Thread
- Zarządzanie siecią Thread przy użyciu OpenThread Daemon
Więcej informacji o usługach Thread i OpenThread znajdziesz w tych materiałach:
- Thread Primer w openthread.io
- Specyfikacja wątku
- Repozytorium OpenThread GitHub
- Dokumentacja interfejsu wiersza poleceń OpenThread
- Dodatkowa obsługa Dockera OpenThread
Możesz też spróbować użyć routera granic OpenThread w kontenerze Dockera.