1. Wstęp
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ł.
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.
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:
- Instancja CLI symulowanego urządzenia z wątkami (węzeł 1)
ot-daemonprocesot-ctlinstancja 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's:
> 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:
- Primer Primer na stronie openthread.io
- Specyfikacja wątku
- Repozytorium OpenThread GitHub
- Dokumentacja wiersza poleceń OpenThread
- Dodatkowa obsługa Dockera OpenThread
Możesz też spróbować użyć routera OpenThread Border w kontenerze Dockera.