Symulowanie sieci wątków przez OpenThread w Dockerze

1. Wprowadzenie

26b7f4f6b3ea0700.png

OpenThread to opracowany przez Google projekt open source protokołu sieciowego Thread. Firma Google Nest wydała platformę OpenThread, by umożliwić deweloperom szerokie udostępnienie technologii Nest w produktach, co przyspiesza tworzenie produktów do domów inteligentnych.

Specyfikacja Thread umożliwia określanie niezawodnego, bezpiecznego i bezpośredniego protokołu komunikacyjnego między urządzeniami w standardzie IPv6. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem połączenia sieci typu mesh i routingiem typu mesh.

Dzięki nim dowiesz się, jak symulować sieć typu Thread na urządzeniach emulowanych przy użyciu Dockera.

Czego się nauczysz

  • Konfigurowanie łańcucha narzędzi OpenThread
  • Jak symulować sieć typu Thread
  • Jak uwierzytelniać węzły węzłów
  • Jak zarządzać siecią wątków za pomocą demona OpenThread

Czego potrzebujesz

  • Docker
  • Podstawowe informacje o systemie Linux, routingu sieci

2. Konfigurowanie Dockera

To ćwiczenie ćwiczeń polega na korzystaniu z Dockera na komputerach z systemem Linux, Mac OS X lub Windows. Zalecanym środowiskiem jest Linux.

Zainstaluj Dockera

Zainstaluj Dockera w wybranym systemie operacyjnym.

Pobierz obraz Dockera

Po zainstalowaniu Dockera otwórz okno terminala i pobierz obraz Dockera openthread/environment. Na tym obrazie widać element OpenThread i demoem OpenThread, który można wykorzystać w tym ćwiczeniu z programowania.

$ docker pull openthread/environment:latest

Pamiętaj, że pobieranie 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 po jego zamknięciu. Nie używaj tej opcji, jeśli nie chcesz usuwać kontenera.

Zwróć uwagę na flagi wymagane na potrzeby tego ćwiczenia:

  • --sysctl net.ipv6.conf.all.disable_ipv6=0 – umożliwia włączenie 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.

Powinien wyświetlić się podobny wiersz w kontenerze:

root@c0f3912a74ff:/#

W powyższym przykładzie c0f3912a74ff to identyfikator kontenera. Identyfikator kontenera kontenera Dockera będzie się różnić od identyfikatora kontenera wyświetlanego w tych ćwiczeniach z programowania.

Korzystanie z Dockera

Zakładamy, że znasz podstawy korzystania z platformy Docker. Należy używać kontenera Dockera do końca ćwiczenia.

3. Symulowanie sieci typu Thread

Przykładowa aplikacja, której użyjesz w ramach tego ćwiczenia z programowania, pokazuje minimalną aplikację OpenThread, która udostępnia interfejsy OpenThread konfiguracji i zarządzania za pomocą interfejsu wiersza poleceń.

To ćwiczenie pozwala wykonać minimalną liczbę kroków za pomocą polecenia ping emulowanego urządzenia z innego urządzenia z emulacją.

Ilustracja poniżej przedstawia podstawową topologię sieci dla wątków. W tym ćwiczeniu będziemy emulować 2 węzły w zielonym kółku: Lider wątku i router Thread, z którym łączy je jedno połączenie.

6e3aa07675f902dc.png

Tworzenie sieci

1. Uruchamianie węzła 1

Jeśli jeszcze tego nie zrobiłeś, uruchom w oknie terminala kontener Dockera i połącz się z 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 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 wyświetli się okno >, naciśnij enter.

Ten plik binarny implementuje urządzenie OpenThread. Sterownik radiowy IEEE 802.15.4 jest zaimplementowany poza protokołem UDP (klatki IEEE 802.15.4 są przekazywane w ładunkach UDP).

Argument 1 to deskryptor pliku, który reprezentuje najmniej istotne bity „przypisanego do fabryki” IEEE EUI-64 dla emulowanego urządzenia. Ta wartość jest także używana podczas łączenia z portem UDP na potrzeby emulacji radiowej IEEE 802.15.4 (port = 9000 + deskryptor pliku). Każde wystąpienie emulowanego urządzenia Thread w ramach tego ćwiczenia będzie korzystać z innego deskryptora pliku.

Uwaga: podczas tworzenia procesu emulacji urządzenia używaj tylko deskryptorów plików z atrybutem 1 lub wyższym, zgodnie z opisem w tym ćwiczeniu z programowania. Deskryptor pliku 0 jest zarezerwowany do innych celów.

Utwórz nowy operacyjny zbiór danych i zatwierdź go jako aktywny. operacyjny zbiór danych to konfiguracja tworzonej sieci typu 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

Uruchomienie protokołu Thread:

> thread start
Done

Zaczekaj kilka sekund i sprawdź, czy urządzenie zostało liderem. Jest ono urządzeniem odpowiedzialnym za zarządzanie przypisywaniem identyfikatora routera.

> state
leader
Done

Wyświetl adresy IPv6 przypisane do interfejsu wątku w węźle 1 (Twoje 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 = mesh-local
  • Zaczyna się od fe80 = link-local

Typy adresów lokalnych sieci typu mesh są dalej klasyfikowane:

  • Zawiera ff:fe00 = lokalizator routera (RLOC)
  • Nie zawiera ff:fe00 = identyfikator punktu końcowego (EID)

Zidentyfikuj identyfikator EID w danych wyjściowych w konsoli i zanotuj go do użycia w przyszłości. W przykładzie powyżej identyfikator EID wygląda tak:

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

2. Uruchamianie węzła 2

Otwórz nowy terminal i wykonaj powłokę bash w obecnie uruchomionym kontenerze Dockera, aby użyć go w węźle 2.

$ docker exec -it codelab_otsim_ctnr bash

W tym nowym wierszu bash wywołaj proces interfejsu wiersza poleceń z argumentem 2. To jest drugie emulowane urządzenie Thread:

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

Uwaga: jeśli po uruchomieniu tego polecenia nie wyświetli się okno >, naciśnij enter.

Skonfiguruj klucz sieciowy i identyfikator PAN, używając tych samych wartości co operacyjnego zbioru danych w węźle 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

Uruchomienie protokołu Thread:

> thread start
Done

Urządzenie zainicjuje się jako dziecko. Element podrzędny wątku jest odpowiednikiem urządzenia końcowego, które jest urządzeniem komunikacyjnym, które przesyła i odbiera ruch jednostronny tylko za pomocą urządzenia nadrzędnego.

> state
child
Done

W ciągu 2 minut powinna pojawić się zmiana stanu z child na router. Router z wątkami może kierować ruch między urządzeniami Thread. Jest on również nazywany „podmiotem nadrzędnym”.

> state
router
Done

Weryfikowanie sieci

Łatwą metodą weryfikacji sieci typu mesh jest sprawdzenie tabeli routera.

1. Sprawdź połączenie

W węźle 2 pobierz RLOC16. RLOC16 to ostatnie 16 bitów adresu IPv6 RLOC na urządzeniu.

> rloc16
5800
Done

W węźle 1 sprawdź tabelę routera pod kątem RLOC16 w węźle 2. 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 RLOC węzła 2 o nazwie 0x5800, co potwierdza, że jest połączone z siatką.

2. Wyślij ping z węzła 1 z węzła 2

Sprawdź połączenie między 2 emulowanymi urządzeniami Thread. W węźle 2 pingEID 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 powrócić do wiersza poleceń >.

Testowanie sieci

Teraz możesz wysłać ping do 2 emulowanych urządzeń z wątkami, przetestuj sieć typu mesh, przełączając jeden węzeł 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 wykryje, że lider (węzeł 1) jest offline i powinno być widoczne przejście z węzła 2 na leader w sieci:

> state
router
Done
...
> state
leader
Done

Po potwierdzeniu zatrzymaj Thread i przywróć węzeł 2 do ustawień fabrycznych, zanim wrócisz do okna Dockera bash. Przywrócimy ustawienia fabryczne, aby zapewnić, że dane logowania do sieci typu Thread użyte w tym ćwiczeniu nie zostaną przeniesione do kolejnego ćwiczenia.

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

Konieczne może być kilkukrotne naciśnięcie enter, aby wyświetlić wiersz > po poleceniu factoryreset. Nie zamykaj kontenera Dockera.

Przywróć też ustawienia fabryczne i zamknij węzeł 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Zapoznaj się z informacjami o wierszu poleceń OpenThread, aby zapoznać się ze wszystkimi dostępnymi poleceniami interfejsu wiersza poleceń.

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 na przesyłanie między urządzeniami ruchu nieuwierzytelnionego połączenia IPv6. Aby można było kierować globalny ruch IPv6 między nimi (i internetem za pomocą routera granicznego Thread), węzły muszą być uwierzytelnione.

Aby się uwierzytelnić, jedno urządzenie musi działać jako komisarz. The Commissioner to obecnie wybrany serwer uwierzytelniania dla nowych urządzeń z wątkami oraz autoryzujący dane logowania do sieci wymagane do dołączenia urządzeń do sieci.

W tym ćwiczeniu użyjemy tej samej topologii z dwoma węzłami. W przypadku uwierzytelniania osoba kierująca wątkiami będzie działać jako komisarz, a router Thread jako połączenie.

d6a67e8a0d0b5dcb.png

Docker

W przypadku każdego węzła (okna terminala) w pozostałych ćwiczeniach sprawdź, czy uruchamiasz kontener Dockera z kompilacją OpenThread. Jeśli przejdziesz do poprzedniego ćwiczenia, w tym samym kontenerze Dockera powinny być już widoczne 2 wiersze poleceń bash. Jeśli tak nie jest, zapoznaj się z krokiem Rozwiązywanie problemów z Dockerem lub po prostu wykonaj ponownie ćwiczenie Symulowanie sieci typu Thread.

1. Utwórz sieć

W węźle 1 wywołaj proces interfejsu wiersza poleceń:

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

Uwaga: jeśli po uruchomieniu tego polecenia nie wyświetli się okno >, 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

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Wyświetl interfejs IPv6

> ifconfig up
Done

Uruchomienie protokołu Thread:

> thread start
Done

Zaczekaj kilka sekund i sprawdź, czy urządzenie zostało liderem:

> state
leader
Done

2. Rozpoczynanie roli „Komisarz”

Będąc nadal na węźle 1, zacznij pełnić rolę komisarza:

> commissioner start
Done

Zezwalaj wszystkim użytkownikom łączącym (przy użyciu symbolu wieloznacznego *) z danymi logowania J01NME na potrzeby łączenia w sieci. Łącznik to urządzenie dodawane przez administratora do zleconej sieci Thread.

> commissioner joiner add * J01NME
Done

3. Rozpoczynanie roli „Łącznik”

W drugim oknie terminala w kontenerze Dockera pojawi 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łącza za pomocą danych uwierzytelniających złącznika J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... poczekaj kilka sekund na potwierdzenie ...

Join success

Urządzenie łączące urządzenie (węzeł 2) zostało uwierzytelnione za pomocą usług komisarza (węzła 1) i otrzymało dane logowania do sieci typu Thread.

Po uwierzytelnieniu węzła 2 uruchom wątek:

> thread start
Done

4. Weryfikacja uwierzytelniania sieci

Sprawdź state w węźle 2, aby upewnić się, że dołączył on do sieci. W ciągu 2 minut węzeł 2 przejdzie z child na router:

> state
child
Done
...
> state
router
Done

5. Resetuj konfigurację

Aby przygotować się do kolejnego ćwiczenia, zresetuj konfigurację. W każdym węźle zatrzymaj Thread, przywróć ustawienia fabryczne i zamknij emulowane urządzenie Thread:

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

Konieczne może być kilkukrotne naciśnięcie enter, aby wyświetlić wiersz > po poleceniu factoryreset.

5. Zarządzanie siecią za pomocą demona OpenThread

W tym ćwiczeniu zasymulujemy 1 instancję interfejsu wiersza poleceń (1 umieszczone urządzenie Thread SoC) i 1 instancję Radio-Cosoror (RCP).

ot-daemon to tryb aplikacji OpenThread Posix, który używa gniazda UNIX jako danych wejściowych i wyjściowych, więc klucz OpenThread może działać jako usługa. Klient może komunikować się z tą usługą przez połączenie z gniazdem za pomocą interfejsu wiersza poleceń OpenThread.

ot-ctl to interfejs wiersza poleceń udostępniany przez usługę ot-daemon, który służy do zarządzania i konfigurowania RCP. Dzięki temu połączysz RCP z siecią utworzoną na urządzeniu Thread.

Docker

W tym ćwiczeniu dla każdego węzła (okna terminala) sprawdź, czy uruchamiasz kontener Dockera z kompilacją OpenThread. Jeśli przejdziesz do poprzedniego ćwiczenia, w tym samym kontenerze Dockera powinny być już widoczne 2 wiersze poleceń bash. Jeśli tak nie jest, zapoznaj się z krokiem Rozwiązywanie problemów z Dockerem.

Użyj demona

W tym ćwiczeniu zostaną wykorzystane 3 okna terminala, które odpowiadają tym zdarzeniom:

  1. Symulowana instancja interfejsu wiersza poleceń (węzeł 1)
  2. Proces usługi ot-daemon
  3. ot-ctl instancja interfejsu wiersza poleceń

1. Uruchamianie węzła 1

W pierwszym oknie terminala wywołaj 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 wyświetli się okno >, 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

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Wyświetl interfejs IPv6

> ifconfig up
Done

Uruchomienie protokołu Thread:

> thread start
Done

Wyświetl adresy IPv6 przypisane do interfejsu wątku w węźle 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
>

Zgodnie z informacjami w kroku Symulowanie sieci obsługującej wątki jeden adres to lokalny link (fe80), a trzy adresy to lokalna sieć typu mesh (fd). Identyfikator EID to adres lokalny typu mesh, który nie zawiera adresu ff:fe00. W tym przykładzie identyfikator EID to fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Określ identyfikator EID z danych wyjściowych ipaddr, które będą używane do komunikacji z węzłem.

2. Włącz demoton

W drugim 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 – jest to normalne i można je zignorować.

Uruchom węzeł ot-daemon w węźle RCP, który wywołamy na węzeł 2. Użyj flagi szczegółowej -v, aby wyświetlić dane wyjściowe dziennika 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ółów 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

Terminal pozostaw otwarty i działający w tle. Nie będziesz już wpisywać poleceń.

3. Dołączanie do sieci przy użyciu trybu offline

Nie zleciliśmy jeszcze węzła 2 (ot-daemon RCP) w sieci typu Thread. Właśnie tu do akcji wkracza ot-ctl. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja wiersza poleceń OpenThread. Dlatego możesz sterować węzłami ot-daemon w taki sam sposób jak inne symulowane urządzenia z wątkami.

Otwórz trzecie okno terminala i uruchom istniejący kontener:

$ docker exec -it codelab_otsim_ctnr bash

Po otwarciu kontenera uruchom polecenie ot-ctl:

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

W tym 3 oknie terminala użyjesz ot-ctl do zarządzania węzłem 2 (węzłem RCP), który rozpoczął się w drugim oknie terminala z ot-daemon. Sprawdź state węzła 2:

> state
disabled
Done

Pobierz klucz eui64 węzła 2, aby ograniczyć dołączanie do węzła łączącego:

> eui64
18b4300000000001
Done

W węźle 1 (oknie pierwszego terminala) uruchom narzędzie Commissioner i ogranicz dołączanie do tego interfejsu API:

> 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, RCP (węzeł 2) został uwierzytelniony za pomocą usług komisarza (węzła 1) i otrzymał dane logowania do sieci typu Thread.

Teraz połącz węzeł 2 z siecią Thread (ponownie w trzecim oknie terminala):

> thread start
Done

4. Weryfikacja uwierzytelniania sieci

W trzecim terminalu sprawdź state w węźle 2, aby upewnić się, że dołączył on do sieci. W ciągu 2 minut węzeł 2 przejdzie z child na router:

> state
child
Done
...
> state
router
Done

5. Sprawdź połączenie

W trzecim oknie terminala zakończ działanie ot-ctl za pomocą polecenia Ctrl+D lub exit i wróć do konsoli bash kontenera. Wyślij ping z konsoli 1 za pomocą jej identyfikatora EID za pomocą polecenia ping6. Jeśli instancja RCP ot-daemon zostanie połączona z siecią Thread i otrzyma połączenie, 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 nie korzystasz z kontenera Dockera

bash potwierdzenia. Może być konieczne sprawdzenie, czy program jest uruchomiony, i w razie potrzeby uruchom go ponownie. Wszelkie kontenery Dockera, które nie zostały utworzone na podstawie opcji --rm, powinny być nadal dostępne.

Aby wyświetlić uruchomione kontenery Dockera:

$ 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 żadnego z poleceń docker ps nie widzisz kontenera codelab_otsim_ctnr, uruchom go jeszcze raz:

$ 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 kontener ma zostać usunięty po zamknięciu.

Jeśli kontener jest zatrzymany (jest 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 (wskazany na liście docker ps), połącz go ponownie z każdym terminalem:

$ docker exec -it codelab_otsim_ctnr bash

Błędy „Operacja niedozwolona”

Jeśli podczas tworzenia nowych węzłów OpenThread (za pomocą polecenia mknod) wystąpią błędy Operation not permitted, upewnij się, że korzystasz z Dockera jako użytkownika głównego zgodnie z poleceniami podanymi w tym ćwiczeniu z programowania. To ćwiczenie z programowania 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 z symulacją OpenThread i zarządzanie nim
  • Symulowanie sieci typu Thread
  • Uwierzytelnianie węzłów w wątku
  • Zarządzanie siecią wątków za pomocą demona OpenThread

Więcej informacji o Thread i OpenThread znajdziesz w tych artykułach:

Możesz też skorzystać z narzędzia OpenThread Border Router w kontenerze Dockera.