Symulowanie sieci wątków przez OpenThread w Dockerze

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

1. Wprowadzenie

26b7f4f6b3ea0700.png

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.

6e3aa07675f902dc.png

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&#39s (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.

d6a67e8a0d0b5dcb.png

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:

  1. Instancja wiersza poleceń symulowanego urządzenia Thread (węzeł 1)
  2. Proces ot-daemon
  3. ot-ctl instancja 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:

Możesz też spróbować użyć routera OpenThread Border w kontenerze Dockera.