Thread-Netzwerk mit OpenThread in Docker simulieren

1. Einführung

26b7f4f6b3ea0700.png

OpenThread von Google ist eine Open-Source-Implementierung des Thread-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um die Technologie, die in Nest-Produkten zum Einsatz kommt, Entwicklern zur Verfügung zu stellen, um die Entwicklung von Produkten für das Smart Home zu beschleunigen.

Die Thread-Spezifikation definiert ein IPv6-basiertes zuverlässiges, sicheres und leistungsstarkes Kommunikationsprotokoll für Geräte zu Hause. OpenThread implementiert alle Thread-Netzwerkebenen, einschließlich IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh-Link-Einrichtung und Mesh-Routing.

Dieses Codelab führt Sie durch die Simulation eines Thread-Netzwerks auf emulierten Geräten mit Docker.

Lerninhalte

  • OpenThread-Build-Toolchain einrichten
  • Thread-Netzwerk simulieren
  • Thread-Knoten authentifizieren
  • Thread-Netzwerk mit OpenThread Daemon verwalten

Voraussetzungen

  • Docker
  • Grundkenntnisse in Linux, Netzwerkrouting

2. Docker einrichten

Dieses Codelab wurde für die Verwendung von Docker auf einem Linux-, Mac OS X- oder Windows-Computer entwickelt. Als Umgebung wird Linux empfohlen.

Docker installieren

Installieren Sie Docker unter dem gewünschten Betriebssystem.

Docker-Image abrufen

Sobald Docker installiert ist, öffnen Sie ein Terminalfenster und rufen Sie das Docker-Image openthread/environment auf. Dieses Image enthält vordefinierte und für dieses Codelab verwendbare OpenThread und OpenThread Daemon.

$ docker pull openthread/environment:latest

Der Download kann einige Minuten dauern.

Starten Sie in einem Terminalfenster einen Docker-Container aus dem Image und stellen Sie eine Verbindung zur bash-Shell her:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Beachten Sie die erforderlichen Flags für dieses Codelab:

  • --sysctl net.ipv6.conf.all.disable_ipv6=0: Dadurch wird IPv6 im Container aktiviert.
  • --cap-add=net_admin: Ermöglicht die Funktion NET_ADMIN, sodass Sie netzwerkbezogene Vorgänge ausführen können, z. B. IP-Routen hinzufügen

Im Container sollten Sie in etwa so sehen:

root@c0f3912a74ff:/#

Im obigen Beispiel ist c0f3912a74ff die Container-ID. Die Container-ID für die Instanz des Docker-Containers unterscheidet sich von der in den Aufforderungen für dieses Codelab.

Docker verwenden

Bei diesem Codelab wird davon ausgegangen, dass Sie die Grundlagen der Verwendung von Docker kennen. Sie sollten das gesamte Codelab im gesamten Docker-Container beibehalten.

3. Thread-Netzwerk simulieren

Die Beispielanwendung, die Sie für dieses Codelab verwenden, veranschaulicht eine minimale OpenThread-Anwendung, die die OpenThread-Konfigurations- und -Verwaltungsschnittstellen über eine einfache Befehlszeile bereitstellt.

In dieser Übung werden Sie durch die erforderlichen Schritte geführt, mit denen ein emuliertes Thread-Gerät von einem anderen emulierten Thread-Gerät aus kontaktiert werden kann.

Die folgende Abbildung beschreibt eine grundlegende Thread-Netzwerktopologie. Für diese Übung emulieren Sie die beiden Knoten im grünen Kreis: Thread-Leader und Thread-Router mit einer einzigen Verbindung zwischen ihnen.

6e3aa07675f902dc

Netzwerk erstellen

1. Knoten 1 starten

Falls noch nicht geschehen, starten Sie den Docker-Containerin einem Terminal-Fenster und verbinden Sie ihn mit der bash Shell:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Geben Sie im Docker-Container den CLI-Prozess für ein emuliertes Thread-Gerät mit dem Binärprogramm ot-cli-ftd aus.

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

Hinweis: Wenn Sie die Aufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.

Dieses Binärprogramm implementiert ein OpenThread-Gerät. Der IEEE 802.15.4-Radiotreiber wird zusätzlich zu UDP implementiert (IEEE 802.15.4-Frames werden innerhalb von UDP-Nutzlasten übergeben).

Das Argument von 1 ist ein Dateideskriptor, der die am wenigsten signifikanten Bits des "Factoryy-assigned&EET EUI-64 für das emulierte Gerät darstellt. Dieser Wert wird auch verwendet, wenn die Bindung an einen UDP-Port für IEEE 802.15.4 erfolgt (Port = 9000 + Dateideskriptor). Für jede Instanz eines emulierten Thread-Geräts in diesem Codelab wird ein anderer Dateideskriptor verwendet.

Hinweis:Verwenden Sie nur Beschreibungen wie 1, die in diesem Codelab angegeben sind, wenn der Vorgang für ein emuliertes Gerät ausgeführt wird. Eine Dateibeschreibung von 0 ist für die andere Verwendung reserviert.

Erstellen Sie ein neues operatives Dataset und übernehmen Sie es als aktives Dataset. Der Operations-Datensatz ist die Konfiguration für das Thread-Netzwerk, das Sie erstellen.

> 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

Führen Sie einen Commit für dieses Dataset als aktiv aus:

> dataset commit active
Done

Rufen Sie die IPv6-Schnittstelle auf:

> ifconfig up
Done

Thread-Protokollvorgang starten:

> thread start
Done

Warten Sie einige Sekunden und prüfen Sie, ob das Gerät der Thread-Lead ist. Der Leader ist das Gerät, das für die Verwaltung der Router-ID-Zuweisung verantwortlich ist.

> state
leader
Done

Sehen Sie sich die IPv6-Adressen an, die der Thread-Schnittstelle von Knoten 1 zugeordnet sind (Ihre Ausgabe sieht anders aus):

> 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

Achten Sie auf die IPv6-Adressen:

  • Beginnt mit fd = Mesh-lokal
  • Beginnt mit fe80 = link-local

Mesh-Lokale-Adressentypen werden weiter klassifiziert:

  • Enthält ff:fe00 = Router-Suche (RLOC)
  • Enthält nicht ff:fe00 = Endpunkt-ID (EID)

Notieren Sie sich die EID in Ihrer Konsolenausgabe, um sie später noch einmal verwenden zu können. In der Beispielausgabe oben lautet die EID:

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

2. Knoten 2 starten

Öffnen Sie ein neues Terminal und führen Sie eine bash-Shell im aktuell ausgeführten Docker-Container aus, der für Knoten 2 verwendet werden soll.

$ docker exec -it codelab_otsim_ctnr bash

Mit dieser neuen bash-Eingabeaufforderung wird der CLI-Prozess mit dem Argument 2 ausgelöst. Dies ist Ihr zweites emuliertes Thread-Gerät:

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

Hinweis:Wenn Sie die Aufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.

Konfigurieren Sie den Thread-Netzwerkschlüssel und die PAN-ID mit denselben Werten wie dem operativen Dataset von Knoten 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Führen Sie einen Commit für dieses Dataset als aktiv aus:

> dataset commit active
Done

Rufen Sie die IPv6-Schnittstelle auf:

> ifconfig up
Done

Thread-Protokollvorgang starten:

> thread start
Done

Das Gerät initialisiert sich als „Untergeordneter“. Ein Thread-Kind entspricht einem Endgerät, das einem Thread-Gerät entspricht, das Unicast-Traffic nur über ein übergeordnetes Gerät überträgt und empfängt.

> state
child
Done

Die Statusänderung sollte innerhalb von 2 Minuten von child zu router wechseln. Thread-Router können Traffic zwischen Thread-Geräten weiterleiten. Es wird auch als übergeordnetes Element bezeichnet.

> state
router
Done

Netzwerk verifizieren

Sie können das Mesh-Netzwerk ganz einfach in der Routertabelle überprüfen.

1. Verbindung prüfen

Rufen Sie auf Knoten 2 den RLOC16 auf. Der RLOC16 sind die letzten 16 Bit der IPv6-Adresse des Geräts.

> rloc16
5800
Done

Prüfen Sie in Knoten 1 die Routertabelle für Knoten 2's RLOC16. Achten Sie darauf, dass Knoten 2 zuerst auf den Routerstatus umgestellt hat.

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

Der RLOC von 0x5800 aus Knoten 2 wurde in der Tabelle gefunden und bestätigt, dass er mit dem Mesh-Netzwerk verbunden ist.

2. Knoten 1 von Knoten 2 kontaktieren

Prüfen Sie die Verbindung zwischen den beiden emulierten Thread-Geräten. In Knoten 2 hat ping die EID zugewiesen, die Knoten 1 zugewiesen ist:

> 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

Drücken Sie enter, um zur Befehlszeile in > zurückzukehren.

Netzwerk testen

Sie können jetzt Ping zwischen zwei emulierten Thread-Geräten kontaktieren. Testen Sie das Mesh-Netzwerk, indem Sie einen Knoten offline nehmen.

Kehren Sie zu Knoten 1 zurück und beenden Sie den Thread:

> thread stop
Done

Wechseln Sie zu Knoten 2 und prüfen Sie den Status. Innerhalb von zwei Minuten erkennt Knoten 2, dass der Leader (Knoten 1) offline ist. Der Knoten 2 sollte in leader umgewandelt werden:

> state
router
Done
...
> state
leader
Done

Wenn Sie bestätigt haben, beenden Sie Thread und setzen Sie Knoten 2 auf die Werkseinstellungen zurück, bevor Sie die Docker-Eingabeaufforderung bash beenden. Durch das Zurücksetzen auf die Werkseinstellungen wird sichergestellt, dass die in dieser Übung verwendeten Thread-Netzwerkanmeldedaten nicht auf die nächste Übung übertragen werden.

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

Möglicherweise müssen Sie enter einige Male drücken, um die Aufforderung > nach einem factoryreset-Befehl zurückzugeben. Verlassen Sie den Docker-Container nicht.

Auch auf Werkseinstellungen zurücksetzen und Knoten 1 beenden:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Weitere Informationen zu allen CLI-Befehlen finden Sie in der Referenz zu CLI (OpenThread).

4. Knoten mit der Authentifizierung authentifizieren

In der vorherigen Übung haben Sie ein Thread-Netzwerk mit zwei simulierten Geräten und bestätigten Konnektivität eingerichtet. Dadurch kann jedoch nicht authentifizierter lokaler IPv6-Link-Traffic zwischen Geräten übertragen werden. Damit der globale IPv6-Traffic zwischen ihnen (und dem Internet über einen Thread-Border-Router) weitergeleitet werden kann, müssen Knoten authentifiziert werden.

Für die Authentifizierung muss ein Gerät als „Provision“ fungieren. Das Kommissionsmitglied ist derzeit der Authentifizierungsserver für neue Thread-Geräte und der Autorisierer, mit dem die Netzwerkanmeldedaten bereitgestellt werden, die erforderlich sind, damit die Geräte dem Netzwerk beitreten können.

In dieser Übung verwenden wir dieselbe Topologie mit zwei Knoten wie zuvor. Für die Authentifizierung fungiert der Thread-Lead als „Commissioner“, der Thread-Router als Joiner.

d6a67e8a0d0b5dcb.pngs

Docker

Achten Sie darauf, dass Sie für jeden Knoten (Terminalfenster) in den verbleibenden Übungen den Docker-Container mit dem OpenThread-Build ausführen. Wenn Sie mit der vorherigen Übung fortfahren, sollten Sie noch zwei bash-Aufforderungen im selben Docker-Container haben. Ist dies nicht der Fall, führen Sie den Schritt Docker-Fehlerbehebung aus oder wiederholen Sie einfach die Übung Thread-Netzwerk simulieren.

1. Netzwerk erstellen

Rufen Sie in Knoten 1 den Befehlszeilenprozess auf:

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

Hinweis: Wenn Sie die Aufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.

Erstellen Sie ein neues operatives Dataset, führen Sie es als aktives aus und starten Sie den Thread:

> 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

Führen Sie einen Commit für dieses Dataset als aktiv aus:

> dataset commit active
Done

Rufen Sie die IPv6-Schnittstelle auf:

> ifconfig up
Done

Thread-Protokollvorgang starten:

> thread start
Done

Warten Sie einige Sekunden und prüfen Sie, ob das Gerät zu einem Thread-Leader geworden ist:

> state
leader
Done

2. Die Rolle „Provisionen“ beginnen

Während Sie sich auf Knoten 1 befinden, starten Sie die Rolle „Provisionen“:

> commissioner start
Done

Alle Joiner (mit dem Platzhalter *) mit den Joiner-Anmeldedaten des Netzwerks J01NME für die Provision für das Netzwerk zulassen. Ein Joiner ist ein Gerät, das von einem menschlichen Administrator in ein Thread-Netzwerk in Auftrag gegeben wurde.

> commissioner joiner add * J01NME
Done

3. Join-Rolle erstellen

Erstellen Sie in einem zweiten Terminalfenster im Docker-Container einen neuen CLI-Prozess. Dies ist Knoten 2.

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

In Knoten 2 aktivieren Sie die Joiner-Rolle mit den J01NME-Teilnehmenden-Anmeldedaten.

> ifconfig up
Done
> joiner start J01NME
Done

... Warte einige Sekunden, bis eine Bestätigung erfolgt ...

Join success

Als Joiner hat sich das Gerät (Knoten 2) erfolgreich mit dem Commissioner (Node 1) authentifiziert und die Thread-Netzwerk-Anmeldedaten erhalten.

Nachdem Sie Knoten 2 authentifiziert haben, starten Sie den Thread:

> thread start
Done

4. Netzwerkauthentifizierung validieren

Prüfen Sie state auf Knoten 2, um zu prüfen, ob es jetzt mit dem Netzwerk verbunden ist. Knoten 2 wechselt innerhalb von zwei Minuten von child zu router:

> state
child
Done
...
> state
router
Done

5. Konfiguration zurücksetzen

Setzen Sie die Konfiguration zurück, um sich auf das nächste Training vorzubereiten. Beenden Sie Thread auf jedem Knoten, setzen Sie es auf die Werkseinstellungen zurück und beenden Sie das emulierte Thread-Gerät:

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

Möglicherweise müssen Sie enter einige Male drücken, um die Aufforderung > nach einem factoryreset-Befehl zurückzugeben.

5. Netzwerk mit OpenThread Daemon verwalten

Für diese Übung werden wir eine CLI-Instanz (ein eingebettetes SoC-Thread-Gerät) und eine Radio-Coprozessor-Instanz (RCP) simulieren.

ot-daemon ist ein Modus der OpenThread Posix-Anwendung, der einen UNIX-Socket als Eingabe und Ausgabe verwendet, damit der OpenThread-Kern als Dienst ausgeführt werden kann. Ein Client kann mit diesem Dienst kommunizieren, indem er sich mit der OpenThread-Befehlszeile als Protokoll mit der Socket verbindet.

ot-ctl ist eine von ot-daemon bereitgestellte Befehlszeile zum Verwalten und Konfigurieren des RCP. Damit wird eine Verbindung zwischen dem RCP und dem Netzwerk hergestellt, das vom Thread-Gerät erstellt wurde.

Docker

Achten Sie darauf, dass Sie für jeden Knoten (Terminalfenster) in dieser Übung den Docker-Container mit dem OpenThread-Build ausführen. Wenn Sie mit der vorherigen Übung fortfahren, sollten Sie im selben Docker-Container zwei bash-Aufforderungen haben. Ist dies nicht der Fall, lesen Sie den Abschnitt zur Fehlerbehebung bei Docker.

ot-daemon verwenden

In dieser Übung werden die folgenden drei Terminalfenster verwendet:

  1. CLI-Instanz des simulierten Thread-Geräts (Knoten 1)
  2. ot-daemon-Prozess
  3. Instanz der ot-ctl-Befehlszeile

1. Knoten 1 starten

Öffnen Sie im ersten Terminalfenster die Befehlszeile für Ihr emuliertes Thread-Gerät:

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

Hinweis:Wenn Sie die Aufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.

Erstellen Sie ein neues operatives Dataset, führen Sie es als aktives aus und starten Sie den Thread:

> 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

Führen Sie einen Commit für dieses Dataset als aktiv aus:

> dataset commit active
Done

Rufen Sie die IPv6-Schnittstelle auf:

> ifconfig up
Done

Thread-Protokollvorgang starten:

> thread start
Done

Sehen Sie sich die IPv6-Adressen an, die der Thread-Schnittstelle von Knoten 1 zugewiesen wurden:

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

Wie im Schritt Thread simulieren erläutert, ist eine Adresse Link-Local (fe80) und drei Mesh-Netzwerk-Adressen (fd). Die EID ist die lokale Mesh-Adresse, die ff:fe00 in der Adresse nicht enthält. In dieser Beispielausgabe ist die EID fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Ermitteln Sie die spezifische EID aus der ipaddr-Ausgabe, die für die Kommunikation mit dem Knoten verwendet wird.

2. OT-DAemon starten

Erstellen Sie im zweiten Terminal einen tun-Geräteknoten und legen Sie Lese-/Schreibberechtigungen fest:

root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200
root@c0f3912a74ff:/# chmod 600 /dev/net/tun

Dieses Gerät wird zur Paketübertragung und zum Empfang auf virtuellen Geräten verwendet. Möglicherweise wird eine Fehlermeldung angezeigt, wenn das Gerät bereits erstellt wurde. Das ist normal und kann ignoriert werden.

Starten Sie ot-daemon für einen RCP-Knoten, der Knoten 2 aufruft. Verwenden Sie das ausführliche -v-Flag, damit Sie die Logausgabe sehen und prüfen können, ob sie ausgeführt wird:

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

Wenn der Vorgang erfolgreich ist, generiert ot-daemon im ausführlichen Modus die folgende Ausgabe:

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

Lassen Sie dieses Terminal offen und laufen im Hintergrund. Sie werden keine weiteren Befehle eingeben.

3. ot-ctl verwenden, um dem Netzwerk beizutreten

Wir haben Knoten 2 (den ot-daemon-RCP) noch nicht an ein Thread-Netzwerk in Auftrag gegeben. Genau hier kommt ot-ctl ins Spiel. ot-ctl verwendet dieselbe Befehlszeile wie die OpenThread-Befehlszeile. Daher können Sie ot-daemon-Knoten genauso wie die anderen simulierten Thread-Geräte steuern.

Öffnen Sie ein drittes Terminalfenster und führen Sie den vorhandenen Container aus:

$ docker exec -it codelab_otsim_ctnr bash

Starten Sie im Container ot-ctl:

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

Sie verwenden ot-ctl in diesem dritten Terminal, um Knoten 2 (den RCP-Knoten) zu verwalten, den Sie im zweiten Terminal mit ot-daemon gestartet haben. Prüfen Sie die state von Knoten 2:

> state
disabled
Done

Rufen Sie Knoten 2 und eui64 auf, um die Verbindung zum bestimmten Joinr zu beschränken:

> eui64
18b4300000000001
Done

Auf Knoten 1 (erstes Terminalfenster) starten Sie den Beauftragten und beschränken die Teilnahme auf diese eui64:

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

Öffnen Sie im dritten Terminal die Netzwerkschnittstelle für Knoten 2 und treten Sie dem Netzwerk bei:

> ifconfig up
Done
> joiner start J01NME
Done

... Warte einige Sekunden, bis eine Bestätigung erfolgt ...

Join success

Als Joiner hat sich der RCP (Node 2) erfolgreich mit dem Commissioner (Node 1) authentifiziert und die Thread-Netzwerk-Anmeldedaten erhalten.

Verknüpfen Sie jetzt Knoten 2 mit dem Thread-Netzwerk (im dritten Terminal-Fenster):

> thread start
Done

4. Netzwerkauthentifizierung validieren

Prüfen Sie im dritten Terminal die state auf Knoten 2, um zu prüfen, ob sie jetzt dem Netzwerk beigetreten ist. Knoten 2 wechselt innerhalb von zwei Minuten von child zu router:

> state
child
Done
...
> state
router
Done

5. Konnektivität prüfen

Beenden Sie im dritten Terminalfenster ot-ctl mit dem Befehl Strg + D oder exit und kehren Sie zur bash-Konsole des Containers zurück. Pingen Sie über diese Konsole Knoten 1 mit seiner EID mit dem Befehl ping6 an. Wenn die ot-daemon-RCP-Instanz erfolgreich mit dem Thread-Netzwerk verbunden wurde und mit diesem kommuniziert, ist der Ping erfolgreich:

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. Docker-Fehlerbehebung

Wenn Sie den Docker-Container beendet haben

bash Aufforderungen prüfen, ob sie ausgeführt werden, und nach Bedarf neu starten/neu eingeben.

So rufen Sie die ausgeführten Docker-Container auf:

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

So rufen Sie alle aktiven und angehaltenen Docker-Container auf:

$ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Wenn der Container codelab_otsim_ctnr in der Ausgabe eines der Befehle docker ps nicht angezeigt wird, führen Sie ihn noch einmal aus:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/environment bash

Wenn der Container angehalten wird (in docker ps -a, aber nicht in docker ps aufgeführt), starten Sie ihn neu:

$ docker start -i codelab_otsim_ctnr

Wenn der Docker-Container bereits ausgeführt wird (in docker ps aufgeführt), verbinden Sie sich in jedem Terminal wieder mit dem Container:

$ docker exec -it codelab_otsim_ctnr bash

Fehler „Vorgang nicht zulässig“

Wenn beim Erstellen neuer OpenThread-Knoten (mit dem mknod-Befehl) Operation not permitted-Fehler auftreten, muss Docker als Root-Nutzer gemäß den in diesem Codelab bereitgestellten Befehlen ausgeführt werden. Dieses Codelab unterstützt das Ausführen von Docker im Root-Modus nicht.

7. Glückwunsch!

Sie haben Ihr erstes Thread-Netzwerk erfolgreich mit OpenThread simuliert. Prima!

Themen in diesem Codelab:

  • OpenThread Simulation Docker-Container starten und verwalten
  • Thread-Netzwerk simulieren
  • Thread-Knoten authentifizieren
  • Thread-Netzwerk mit OpenThread Daemon verwalten

Weitere Informationen zu Thread und OpenThread finden Sie hier:

Alternativ können Sie auch OpenThread Border Router in einem Docker-Container verwenden.