Symulowanie sieci wątków przez OpenThread w Dockerze

1. Wstęp

26b7f4f6b3ea0700.png

OpenThread udostępniany przez Google to implementacja protokołu open source protokołu sieciowego Thread. Google Nest wprowadziła usługę OpenThread, aby umożliwić deweloperom szeroko dostępną technologię związaną z produktami Nest. Przyspiesza to tworzenie produktów dla domu inteligentnego.

Specyfikacja wątku definiuje w protokole komunikacyjnym między urządzeniami niezawodne, bezpieczne i bezprzewodowe protokół IPv6 na potrzeby aplikacji domowych. OpenThread wdraża wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem linku w sieci typu mesh i routingiem sieci typu mesh.

Dzięki nim dowiesz się, jak za pomocą Dockera symulować sieć wątków na urządzeniach emulowanych.

Czego się nauczysz

  • Jak skonfigurować łańcuch kompilacji OpenThread
  • Symulowanie sieci z wątkami
  • Jak uwierzytelnić węzły wątku
  • Jak zarządzać siecią z wątkami za pomocą demona OpenThread

Czego potrzebujesz

  • Docker
  • Podstawowa wiedza na temat systemu Linux i routingu sieci

2. Skonfiguruj Dockera

To ćwiczenie ćwiczeń z programowania jest przeznaczone do korzystania z platformy Docker na komputerach z systemem Linux, Mac OS X i Windows. Zalecane jest środowisko Linux.

Zainstaluj Dockera

Zainstaluj Dockera z wybranego systemu operacyjnego.

Pociągnij obraz Dockera

Po zainstalowaniu Dockera otwórz okno terminala i pobierz obraz Dockera (openthread/environment). Ten obraz zawiera gotowe i gotowe do użytku ćwiczenia z kempingów OpenThread i OpenThread.

$ 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 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 w tym ćwiczeniu z programowania:

  • --sysctl net.ipv6.conf.all.disable_ipv6=0 – spowoduje włączenie protokołu IPv6 w kontenerze.
  • --cap-add=net_admin – umożliwia korzystanie z funkcji NET_ADMIN, która pozwala wykonywać operacje związane z siecią, takie jak dodawanie tras IP

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

root@c0f3912a74ff:/#

W podanym wyżej przykładzie c0f3912a74ff jest identyfikatorem kontenera. Identyfikator kontenera Twojego wystąpienia kontenera Dockera różni się od identyfikatora widocznego w wierszach poleceń tego ćwiczenia z programowania.

Korzystanie z Dockera

W tym ćwiczeniu zakładamy, że znasz podstawy korzystania z Dockera. Musisz używać kontenera Dockera na cały czas ćwiczeń z programowania.

3. Symulowanie sieci z wątkami

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

W tym ćwiczeniu wykonasz minimalne czynności, które są wymagane, aby wysłać ping do emulowanego urządzenia Thread z innego emulowanego urządzenia Thread.

Poniższa ilustracja przedstawia podstawową topologie sieci. W tym ćwiczeniu emulujemy 2 węzły w zielonym okręgu: lidera w wątku i router nici. Łączy je jeden węzeł.

6e3aa07675f902dc.png

Utwórz sieć

1. Uruchom węzeł 1

Jeśli w terminalu nie zostało to jeszcze zrobione, 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. Przewód sterownika IEEE 802.15.4 jest zaimplementowany w połączeniu z protokołem UDP (ramki IEEE 802.15.4 są przekazywane w ładunkach UDP).

Argument 1 to deskryptor pliku reprezentujący najmniej ważne bity „przypisane do fabryki” w standardzie 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 z wątkiem 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 1 lub większych wymienionych w tym ćwiczeniu Codelab. Deskryptor pliku 0 jest zarezerwowany do innych celów.

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

Zatwierdź 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

Zaczekaj kilka sekund i sprawdź, czy urządzenie zostało liderem w wątku. Lider to urządzenie, które służy do zarządzania przypisywaniem identyfikatorów routerów.

> state
leader
Done

Wyświetl adresy IPv6 przypisane do interfejsu wątku 1 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 poszczególne typy adresów IPv6:

  • Zaczyna się od fd = mesh-local
  • Zaczyna się od fe80 = link-local

Rodzaje adresów sieci typu mesh są dodatkowo 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 późniejszego użycia. W przykładowym wyniku powyżej identyfikator EID wygląda tak:

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

2. Uruchom węzeł 2

Otwórz nowy terminal i uruchom powłokę bash w aktywnym kontenerze Dockera, który będzie używany w węźle 2.

$ docker exec -it codelab_otsim_ctnr bash

W tym nowym wierszu bash wykonaj 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 widzisz komunikatu >, naciśnij enter.

Skonfiguruj klucz sieciowy IDENTYFIKATOR i identyfikator PAN, korzystając z tych samych wartości, co źródłowy węzeł 1 i #39

> 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

Uruchom operację protokołu Thread:

> thread start
Done

Urządzenie zainicjuje się jako podmiot podrzędny. Jednostka podrzędna wątku jest odpowiednikiem urządzenia końcowego, które jest urządzeniem wysyłającym i odbierającym ruch jednostronny tylko za pomocą urządzenia nadrzędnego.

> state
child
Done

Zmiana stanu z child na router powinna pojawić się w ciągu 2 minut. Router Threader może kierować ruch między urządzeniami Thread. Nazywany także podmiotem nadrzędnym.

> state
router
Done

Weryfikowanie sieci

Łatwą metodą weryfikacji sieci typu mesh jest przyjrzenie się tabeli routerów.

1. Sprawdź połączenie

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

> rloc16
5800
Done

W węźle 1 sprawdź tabelę routera pod kątem węzła 2&RL36. Najpierw sprawdź, czy węzeł 2 został przełączony 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 z 0x5800, co potwierdza, że jest ono połączone z siecią typu mesh.

2. Ping – węzeł 1 z węzła 2

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

Testowanie sieci

Teraz, gdy możesz wykonywać pingi między 2 emulowanymi urządzeniami 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, a przejście węzła 2 powinno być leader sieci:

> state
router
Done
...
> state
leader
Done

Po potwierdzeniu zatrzymaj wątek i przywróć na urządzeniu węzeł 2 przed przywróceniem do bash. Przywrócimy dane fabryczne, aby mieć pewność, że dane logowania do sieci używane przez ten wątek nie zostaną przeniesione do następnego ćwiczenia.

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

Być może trzeba będzie kilka razy nacisnąć enter, aby wyświetlić komunikat > po poleceniu factoryreset. Nie zamykaj kontenera Dockera.

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

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Wszystkie dostępne polecenia interfejsu wiersza poleceń znajdziesz w dokumentacji wiersza poleceń OpenThread.

4. Uwierzytelnianie węzłów za pomocą prowizji

W poprzednim ćwiczeniu udało nam się skonfigurować sieć w wątku z 2 symulowanymi urządzeniami i zweryfikowanym połączeniem. Umożliwia to jednak przekazywanie lokalnego urządzenia nieuwierzytelnionego ruchu IPv6 z linkiem. Aby kierować globalny ruch IPv6 między nimi (i z internetu przez router obramowania Thread), węzły muszą być uwierzytelnione.

Aby uwierzytelnić, jedno urządzenie musi działać jako komisarz. Commissioner jest obecnie wybranym serwerem uwierzytelniania w przypadku nowych urządzeń z wątkiem. Autoryzator udostępnia dane logowania do sieci wymagane przez urządzenia do dołączenia do sieci.

W tym ćwiczeniu użyjemy tej samej topologii z dwoma węzłami. W przypadku uwierzytelniania Threader będzie działać jako Komisarz, a router do nici jako połączenie.

d6a67e8a0d0b5dcb.png

Docker

W przypadku pozostałych węzłów (okna terminala) w pozostałych ćwiczeniach upewnij się, że uruchomiony jest kontener Dockera z kompilacją OpenThread. Jeśli przejdziesz do poprzedniego ćwiczenia, w tym samym kontenerze Dockera powinny się już znajdować dwa monity bash. Jeśli tak się nie stanie, 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 tworzy proces interfejsu 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

Zatwierdź 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

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

> state
leader
Done

2. Rozpocznij rolę Komisarza

Nie wychodząc z węzła 1, uruchom rolę Komisarza:

> commissioner start
Done

Zezwalaj na dołączanie każdego uczestnika (z użyciem symbolu wieloznacznego *) za pomocą danych logowania J01NME w celu dołączenia do sieci. Łącznik to urządzenie, które jest dodawane przez zleconego administratora do zleconej sieci Thread.

> commissioner joiner add * J01NME
Done

3. Rozpoczynanie roli Łącznika

W drugim oknie terminala w kontenerze Dockera pojawią się nowe procesy 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ę Łącznik przy użyciu danych logowania J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... poczekaj kilka sekund w celu potwierdzenia ...

Join success

Urządzenie łączące (węzł 2) uwierzytelniło się w usłudze Komisarz (węzeł 1) i otrzymywało dane logowania do sieci Thread.

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

> thread start
Done

4. Sprawdź uwierzytelnianie sieci

Sprawdź węzeł state w węźle 2, aby się upewnić, że został on już dołączony do sieci. W ciągu 2 minut węzeł 2 przechodzi 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 wątek, przywróć ustawienia fabryczne i zamknij emulowane urządzenie Thread:

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

Być może trzeba będzie kilka razy nacisnąć enter, aby wyświetlić komunikat > po poleceniu factoryreset.

5. Zarządzanie siecią z demonem OpenThread

W tym ćwiczeniu zasymulujemy jedną instancję interfejsu wiersza poleceń (pojedyncze urządzenie osadzone SoC Thread) i jedno wystąpienie radiowego procesora (RCP).

ot-daemon to tryb aplikacji OpenThread Posix, który używa gniazda UNIX jako źródła danych wejściowych, aby można było uruchomić ją jako usługę. Klient może komunikować się z tą usługą przez połączenie z gniazdem przy użyciu interfejsu wiersza poleceń OpenThread.

ot-ctl to interfejs wiersza poleceń udostępniany przez ot-daemon do zarządzania i konfigurowania RCP. W ten sposób połączysz RCP z siecią utworzoną przez urządzenie Thread.

Docker

W przypadku każdego węzła (okna terminala) w tym ćwiczeniu sprawdź, czy uruchamiasz kontener Dockera za pomocą kompilacji OpenThread. Jeśli przejdziesz do poprzedniego ćwiczenia, w tym samym kontenerze Dockera powinny być już widoczne dwa monity bash. Jeśli tak nie jest, przeczytaj sekcję Rozwiązywanie problemów z dockerem.

Użyj demotona

W tym ćwiczeniu zostaną użyte 3 okna terminala:

  1. Instancja CLI symulowanego urządzenia z wątkami (węzeł 1)
  2. ot-daemon proces
  3. ot-ctl instancja interfejsu wiersza poleceń

1. Uruchom węzeł 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 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

Zatwierdź 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ątku 1&#39s:

> 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 ramach kroku Symulowanie sieci wątków, jeden adres to „link lokalny” (fe80), a trzy to „siatka lokalna” (fd). Identyfikator EID to adres lokalny typu mesh, który nie zawiera ff:fe00 w adresie. W tym przykładowym pliku EID widać fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Określ identyfikator EID z danych wyjściowych ipaddr, który będzie używany do komunikacji z węzłem.

2. Uruchom demoton

W 2 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 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ę komunikat o błędzie – to normalne i można je zignorować.

Uruchamiaj węzeł ot-daemon węzła RCP, który będzie nazywać węzeł 2. Użyj flagi szczegółowej -v, aby wyświetlić dane wyjściowe dziennika i potwierdzić, że jest ono uruchomione:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty://openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'

Po udanym działaniu ot-daemon w trybie szczegółowego 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

Zostaw ten terminal otwarty i działaj w tle. Nie będziesz już wpisywać żadnych poleceń.

3. Aby dołączyć do sieci, użyj OT-Ctrl

Jeszcze nie zleciliśmy węzła 2 (RCP ot-daemon) w żadnej sieci Thread. Tutaj zaczyna się ot-ctl. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja OpenThread CLI. Dlatego możesz sterować ot-daemon węzłami tak samo jak inne symulowane urządzenia Thread.

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

$ docker exec -it codelab_otsim_ctnr bash

Uruchom kontener (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 z ot-daemon użyj ot-ctl. Sprawdź state węzła 2:

> state
disabled
Done

Aby ograniczyć dołączanie do określonego złącza, pobierz węzeł eui64 2 i 39:

> eui64
18b4300000000001
Done

W węźle 1 (okno pierwszego terminala) uruchom narzędzie Commissioner i ogranicz dostęp tylko do tego interfejsu API:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

W oknie trzeciego terminala wyświetl interfejs sieci węzła 2 i dołącz do sieci:

> ifconfig up
Done
> joiner start J01NME
Done

... poczekaj kilka sekund w celu potwierdzenia ...

Join success

RCP (Node 2) – organizacja łącząca się, uwierzytelniła się w usłudze Commissioner (Node 1) i odebrała dane logowania Thread Network.

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

> thread start
Done

4. Sprawdź uwierzytelnianie sieci

W trzecim terminalu sprawdź state w węźle 2, aby się upewnić, że dołączył on do sieci. W ciągu 2 minut węzeł 2 przechodzi 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. Z tej konsoli 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 się powiedzie:

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 Możliwe polecenia – może być konieczne sprawdzenie, czy środowisko biegnie, a następnie w razie potrzeby uruchomi się ponownie.

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 uruchomione, 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 wynikach polecenia 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

Jeśli kontener został zatrzymany (wyświetlany 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 (jest w docker ps), połącz go z każdym terminalem:

$ docker exec -it codelab_otsim_ctnr bash

"Błędy dotyczące niedozwolonego"

Jeśli podczas tworzenia nowych węzłów OpenThread wystąpią błędy Operation not permitted (przy użyciu polecenia mknod), upewnij się, że uruchamiasz Dockera jako użytkownika głównego zgodnie z poleceniami podanymi w tym ćwiczeniu z programowania. To ćwiczenie programowania nie obsługuje uruchamiania Dockera w trybie bez roota.

7. Gratulacje!

Udało Ci się zasymulować pierwszą sieć Threading za pomocą OpenThread. Świetnie!

Dzięki nim dowiesz się, jak:

  • Uruchamianie kontenera Dockera Symulacji OpenThread i zarządzanie nim
  • Symulowanie sieci z wątkami
  • Uwierzytelnianie węzłów wątku
  • Zarządzanie siecią wątku z demonem 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.