Symulowanie sieci Thread przy użyciu OpenThread w Dockerze

1. Wprowadzenie

OpenThread to udostępniona przez Google implementacja open source protokołu sieciowego Thread. Google Nest udostępnił OpenThread, aby technologia używana w produktach Nest była szeroko dostępna dla deweloperów i przyspieszała tworzenie produktów do domów inteligentnych.

Specyfikacja Thread definiuje niezawodny, bezpieczny i energooszczędny protokół komunikacji bezprzewodowej między urządzeniami oparty na IPv6, przeznaczony do zastosowań domowych. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanawianie połączeń siatkowych i routing siatkowy.

W tym ćwiczeniu z programowania dowiesz się, jak symulować sieć Thread na emulowanych urządzeniach za pomocą Dockera.

Czego się nauczysz

Konfigurowanie łańcucha narzędzi do kompilacji OpenThread
Symulowanie sieci Thread
Jak uwierzytelniać węzły Thread
Jak zarządzać siecią Thread za pomocą demona OpenThread

Czego potrzebujesz

Docker
podstawowa wiedza o systemie Linux i routingu sieciowym;

2. Skonfiguruj Dockera

Ten Codelab jest przeznaczony do używania Dockera na komputerze z systemem Linux, Mac OS X lub Windows. Zalecane jest środowisko 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. Na tym obrazie widać wstępnie skompilowane i gotowe do użycia w tym ćwiczeniu OpenThread i OpenThread Daemon.

$ 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 usunąć kontenera.

Zwróć uwagę na flagi, które są wymagane w tym ćwiczeniu:

--sysctl net.ipv6.conf.all.disable_ipv6=0 – włącza IPv6 w kontenerze.
--cap-add=net_admin – włącza uprawnienie NET_ADMIN, które umożliwia wykonywanie operacji związanych z siecią, np. dodawanie tras IP.

Po wejściu do kontenera powinien pojawić się prompt podobny do tego:

root@c0f3912a74ff:/#

W powyższym przykładzie c0f3912a74ff to identyfikator kontenera. Identyfikator kontenera w Twojej instancji kontenera Dockera będzie się różnić od identyfikatora podanego w promptach w tym Codelabie.

Korzystanie z Dockera

W tym przewodniku zakładamy, że znasz podstawy korzystania z Dockera. Przez cały czas trwania Codelabu musisz pozostawać w kontenerze Dockera.

3. Symulowanie sieci Thread

Przykładowa aplikacja, której użyjesz w tym module, to minimalna aplikacja OpenThread, która udostępnia interfejsy konfiguracji i zarządzania OpenThread za pomocą podstawowego interfejsu wiersza poleceń.

W tym ćwiczeniu wykonasz minimalne czynności wymagane do pingowania jednego emulowanego urządzenia Thread z innego emulowanego urządzenia Thread.

Rysunek poniżej przedstawia podstawową topologię sieci Thread. W tym ćwiczeniu będziemy emulować 2 węzły w zielonym okręgu: lidera sieci Thread i routera Thread z pojedynczym połączeniem między nimi.

Tworzenie sieci

1. Uruchamianie węzła 1

Jeśli jeszcze tego nie zrobiono, 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 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 widzisz prompta >, naciśnij enter.

Ten plik binarny implementuje urządzenie OpenThread. Sterownik radiowy IEEE 802.15.4 jest zaimplementowany na podstawie protokołu UDP (ramki IEEE 802.15.4 są przekazywane w ładunkach UDP).

Argumentem funkcji 1 jest deskryptor pliku, który reprezentuje najmniej znaczące bity „przypisanego fabrycznie” identyfikatora IEEE EUI-64 emulowanego urządzenia. Ta wartość jest też używana podczas wiązania z portem UDP na potrzeby emulacji radia IEEE 802.15.4 (port = 9000 + deskryptor pliku). Każde wystąpienie emulowanego urządzenia Thread w tym laboratorium kodowym będzie używać innego deskryptora pliku.

Uwaga: podczas tworzenia procesu dla emulowanego urządzenia używaj tylko deskryptorów plików o wartości 1 lub większej, jak podano w tym Codelabie. 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

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Włącz interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację protokołu Thread:

> thread start
Done

Odczekaj kilka sekund i sprawdź, czy urządzenie stało się liderem sieci Thread. Lider to urządzenie odpowiedzialne za zarządzanie przypisywaniem identyfikatorów 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 = mesh-local
Zaczyna się od fe80 = połączenie lokalne

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

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

Znajdź identyfikator EID w danych wyjściowych konsoli i zapisz go, aby użyć go później. W przykładowych danych wyjściowych powyżej identyfikator EID to:

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

2. Węzeł początkowy 2

Otwórz nowy terminal i wykonaj powłokę bash w aktualnie działającym kontenerze Dockera, aby użyć jej w przypadku węzła 2.

$ docker exec -it codelab_otsim_ctnr bash

W nowym wierszu poleceń bash uruchom proces interfejsu wiersza poleceń z argumentem 2. To 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 prompta >, naciśnij enter.

Skonfiguruj klucz sieci Thread i identyfikator PAN, używając tych samych wartości co w przypadku operacyjnego zbioru danych węzła 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Włącz interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację protokołu Thread:

> thread start
Done

Urządzenie zostanie zainicjowane jako urządzenie dziecka. Urządzenie podrzędne Thread jest odpowiednikiem urządzenia końcowego, czyli urządzenia Thread, które przesyła i odbiera ruch unicast tylko z urządzeniem nadrzędnym.

> state
child
Done

W ciągu 2 minut stan powinien zmienić się z child na router. Router Thread może kierować ruch między urządzeniami Thread. Jest on również nazywany rodzicem.

> state
router
Done

Weryfikowanie sieci

Łatwym sposobem na sprawdzenie sieci typu mesh jest przyjrzenie się tabeli routerów.

1. Sprawdź połączenie

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

> rloc16
5800
Done

Na węźle 1 sprawdź w tabeli routera RLOC16 węzła 2. Najpierw upewnij się, że urządzenie Node 2 przełączyło się w 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 znajduje się RLOC węzła 2 o wartości 0x5800, co potwierdza, że jest on połączony z siecią mesh.

2. Pingowanie węzła 1 z węzła 2

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

Testowanie sieci

Skoro możesz już pingować 2 emulowane urządzenia Thread, przetestuj sieć typu mesh, wyłączając jeden węzeł.

Wróć do węzła 1 i zatrzymaj Thread:

> thread stop
Done

Przejdź do węzła 2 i sprawdź stan. W ciągu 2 minut węzeł 2 wykryje, że węzeł 1 (lider) jest offline, i powinien przejść do roli leader w sieci:

> state
router
Done
...
> state
leader
Done

Po potwierdzeniu zatrzymaj Thread i przywróć ustawienia fabryczne węzła 2, a następnie wróć do wiersza poleceń Dockera bash. Przywrócenie ustawień fabrycznych ma na celu zapewnienie, że dane logowania do sieci Thread użyte w tym ćwiczeniu nie zostaną przeniesione do następnego ćwiczenia.

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

Po wykonaniu polecenia factoryreset może być konieczne kilkukrotne naciśnięcie klawisza enter, aby przywrócić prompt >. Nie opuszczaj kontenera Dockera.

Przywróć też do ustawień fabrycznych i zamknij węzeł 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Aby poznać wszystkie dostępne polecenia interfejsu wiersza poleceń, zapoznaj się z dokumentacją OpenThread CLI.

4. Uwierzytelnianie węzłów za pomocą funkcji Commissioning

W poprzednim ćwiczeniu skonfigurowaliśmy sieć Thread z 2 symulowanymi urządzeniami i sprawdziliśmy połączenie. Umożliwia to jednak przesyłanie między urządzeniami tylko nieuwierzytelnionego ruchu IPv6 w połączeniu lokalnym. Aby kierować globalny ruch IPv6 między nimi (i Internetem za pomocą routera granicznego Thread), węzły muszą być uwierzytelnione.

Aby przeprowadzić uwierzytelnianie, jedno z urządzeń musi pełnić rolę komisarza. Komisarz to aktualnie wybrany serwer uwierzytelniania dla nowych urządzeń Thread i osoba upoważniona do udostępniania danych logowania do sieci wymaganych do dołączenia urządzeń do sieci.

W tym ćwiczeniu użyjemy tej samej topologii z 2 węzłami co wcześniej. Na potrzeby uwierzytelniania urządzenie Thread Leader będzie pełnić funkcję komisarza, a router Thread – funkcję urządzenia dołączającego.

Docker

W przypadku każdego węzła (okna terminala) w pozostałych ćwiczeniach upewnij się, że kontener Dockera jest uruchomiony z kompilacją OpenThread. Jeśli kontynuujesz poprzednie ćwiczenie, w tym samym kontenerze Dockera powinny być otwarte 2 prompty bash. Jeśli nie, zapoznaj się z krokiem Rozwiązywanie problemów z Dockerem lub po prostu powtórz ćwiczenie Symulowanie sieci Thread.

1. Tworzenie sieci

W węźle 1 uruchom proces interfejsu wiersza poleceń:

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

Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.

Utwórz nowy operacyjny zbiór danych, 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

Włącz interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację protokołu Thread:

> thread start
Done

Poczekaj kilka sekund i sprawdź, czy urządzenie stało się liderem sieci Thread:

> state
leader
Done

2. Rozpoczęcie roli komisarza

Na węźle 1 uruchom rolę komisarza:

> commissioner start
Done

Zezwól każdemu urządzeniu dołączającemu (za pomocą symbolu wieloznacznego *) z J01NME danymi logowania urządzenia dołączającego na włączenie się do sieci. Urządzenie dołączające to urządzenie dodane przez administratora do uruchomionej sieci Thread.

> commissioner joiner add * J01NME
Done

3. Rozpoczęcie roli dołączającego

W drugim oknie terminala w kontenerze Dockera utwórz nowy proces interfejsu wiersza poleceń. To jest węzeł 2.

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

Na węźle 2 włącz rolę dołączającego za pomocą J01NME Joiner Credential.

> ifconfig up
Done
> joiner start J01NME
Done

... poczekaj kilka sekund na potwierdzenie ...

Join success

Urządzenie (węzeł 2) zostało uwierzytelnione przez urządzenie pełniące rolę komisarza (węzeł 1) i otrzymało dane logowania do sieci Thread.

Po uwierzytelnieniu węzła 2 uruchom Thread:

> thread start
Done

4. Weryfikowanie uwierzytelniania sieci

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

> state
child
Done
...
> state
router
Done

5. Resetuj konfigurację

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

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

Po wykonaniu polecenia factoryreset może być konieczne kilkukrotne naciśnięcie klawisza enter, aby przywrócić prompt >.

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

W tym ćwiczeniu zasymulujemy 1 instancję interfejsu CLI (jedno wbudowane urządzenie SoC Thread) i 1 instancję koprocesora radiowego (RCP).

ot-daemon to tryb aplikacji OpenThread Posix, który używa gniazda UNIX jako wejścia i wyjścia, dzięki czemu rdzeń 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 ot-daemon do zarządzania platformą RCP i jej konfigurowania. W ten sposób połączymy RCP z siecią utworzoną przez urządzenie Thread.

Docker

W przypadku każdego węzła (okna terminala) w tym ćwiczeniu upewnij się, że kontener Dockera jest uruchomiony z kompilacją OpenThread. Jeśli kontynuujesz poprzednie ćwiczenie, powinny być już otwarte 2 prompty bash w tym samym kontenerze Dockera. W przeciwnym razie przejdź do kroku Rozwiązywanie problemów z Dockerem.

Używanie ot-daemon

W tym ćwiczeniu użyjemy 3 okien terminala, które odpowiadają tym elementom:

Instancja interfejsu wiersza poleceń symulowanego urządzenia Thread (węzeł 1)
Proces usługi ot-daemon
Instancja interfejsu wiersza poleceń ot-ctl

1. Uruchamianie węzła 1

W pierwszym oknie terminala uruchom 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 prompta >, naciśnij enter.

Utwórz nowy operacyjny zbiór danych, 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

Włącz interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację 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śniono w kroku Symulowanie sieci Thread, jeden adres jest adresem lokalnym połączenia (fe80), a trzy są adresami lokalnymi siatki (fd). Identyfikator EID to adres lokalny siatki, który nie zawiera w adresie znaku ff:fe00. W tym przykładzie identyfikator EID to fd55:cf34:dea5:7994:460:872c:e807:c4ab.

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

2. Uruchomienie ot-daemon

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. Jest to normalne i można go zignorować.

Uruchom ot-daemon dla węzła RCP, który nazwiemy Węzeł 2. Użyj flagi -v verbose, aby wyświetlić dane wyjściowe logu i potwierdzić, że skrypt 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 polecenie ot-daemon w trybie szczegółowym zakończy się powodzeniem, 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 działający w tle. Nie będziesz w nim wpisywać żadnych innych poleceń.

3. Dołączanie do sieci za pomocą ot-ctl

Węzeł 2 (ot-daemon RCP) nie został jeszcze przypisany do żadnej sieci Thread. W tym momencie pojawia się ot-ctl. ot-ctl korzysta z tego samego interfejsu wiersza poleceń co aplikacja OpenThread CLI. Dlatego możesz sterować węzłami ot-daemon w taki sam sposób jak innymi symulowanymi urządzeniami Thread.

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

$ docker exec -it codelab_otsim_ctnr bash

Po wejściu do kontenera uruchom ot-ctl:

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

W tym trzecim oknie terminala użyjesz znaku ot-ctl do zarządzania węzłem 2 (węzłem RCP), który został uruchomiony w drugim oknie terminala za pomocą znaku ot-daemon. Sprawdź state węzła 2:

> state
disabled
Done

Pobierz eui64 węzła 2, aby ograniczyć możliwość dołączenia do konkretnego urządzenia:

> eui64
18b4300000000001
Done

Na węźle 1 (w pierwszym oknie terminala) uruchom urządzenie Commissioner i ogranicz możliwość dołączania tylko do tego identyfikatora eui64:

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

W trzecim oknie terminala uruchom interfejs sieciowy dla węzła 2 i dołącz do sieci:

> ifconfig up
Done
> joiner start J01NME
Done

... poczekaj kilka sekund na potwierdzenie ...

Join success

Urządzenie dołączające (węzeł 2) zostało pomyślnie uwierzytelnione przez urządzenie zarządzające (węzeł 1) i otrzymało dane logowania do sieci Thread.

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

> thread start
Done

4. Weryfikowanie uwierzytelniania sieci

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

> state
child
Done
...
> state
router
Done

5. Sprawdzanie połączenia

W trzecim oknie terminala zamknij ot-ctl, używając Ctrl+D lub polecenia exit, i wróć do konsoli bash kontenera. W tej konsoli wyślij ping do węzła 1, używając jego identyfikatora EID z poleceniem ping6. Jeśli instancja ot-daemon RCP zostanie pomyślnie połączona z siecią Thread i będzie się z nią komunikować, pingowanie 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 opuścisz kontener Dockera

bash promptów, może być konieczne sprawdzenie, czy działa, i w razie potrzeby ponowne uruchomienie lub wpisanie. Wszystkie utworzone przez Ciebie kontenery Dockera, w których nie użyto opcji --rm, powinny nadal istnieć.

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 danych wyjściowych żadnego z poleceń docker ps nie widzisz kontenera codelab_otsim_ctnr, uruchom je 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 został usunięty po jego zamknięciu.

Jeśli kontener jest zatrzymany (znajduje się na liście w sekcji docker ps -a, ale nie w sekcji docker ps), uruchom go ponownie:

$ docker start -i codelab_otsim_ctnr

Jeśli kontener Dockera jest już uruchomiony (znajduje się na liście docker ps), ponownie połącz się z nim w każdym terminalu:

$ docker exec -it codelab_otsim_ctnr bash

Błędy „Operacja niedozwolona”

Jeśli podczas tworzenia nowych węzłów OpenThread (za pomocą polecenia mknod) napotkasz błędy Operation not permitted, upewnij się, że uruchamiasz Dockera jako użytkownik root zgodnie z poleceniami podanymi w tym Codelabie. Te warsztaty nie obsługują uruchamiania Dockera w trybie bez uprawnień roota.

7. Gratulacje!

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

Z tego modułu dowiedzieliśmy się, jak:

Uruchamianie kontenera Dockera symulacji OpenThread i zarządzanie nim
Symulowanie sieci Thread
Uwierzytelnianie węzłów Thread
Zarządzanie siecią Thread za pomocą demona OpenThread

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

Możesz też wypróbować router graniczny OpenThread w kontenerze Dockera.

Symulowanie sieci Thread przy użyciu OpenThread w Dockerze Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

1. Wprowadzenie

Czego się nauczysz

Czego potrzebujesz

2. Skonfiguruj Dockera

Zainstaluj Dockera

Pobieranie obrazu Dockera

Korzystanie z Dockera

3. Symulowanie sieci Thread

Tworzenie sieci

1. Uruchamianie węzła 1

2. Węzeł początkowy 2

Weryfikowanie sieci

1. Sprawdź połączenie

2. Pingowanie węzła 1 z węzła 2

Testowanie sieci

4. Uwierzytelnianie węzłów za pomocą funkcji Commissioning

Docker

1. Tworzenie sieci

2. Rozpoczęcie roli komisarza

3. Rozpoczęcie roli dołączającego

4. Weryfikowanie uwierzytelniania sieci

5. Resetuj konfigurację

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

Docker

Używanie ot-daemon

1. Uruchamianie węzła 1

2. Uruchomienie ot-daemon

3. Dołączanie do sieci za pomocą ot-ctl

4. Weryfikowanie uwierzytelniania sieci

5. Sprawdzanie połączenia

6. Rozwiązywanie problemów z Dockerem

Błędy „Operacja niedozwolona”

7. Gratulacje!

Symulowanie sieci Thread przy użyciu OpenThread w Dockerze