Thread-Netzwerk mit OpenThread in Docker simulieren

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Einführung

26b7f4f6b3ea0700.png

OpenThread ist eine Open-Source-Implementierung des Netzwerkprotokolls Thread von Google. Google Nest hat OpenThread veröffentlicht, um die in Nest-Produkten verwendete Technologie allgemein für Entwickler verfügbar zu machen. So kann die Entwicklung von Produkten für das Smart Home beschleunigt werden.

In der Thread-Spezifikation ist ein IPv6-basiertes zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für Geräte zwischen Geräten für Heimanwendungen definiert. 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

  • Build-Toolchain von OpenThread 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 entwickelt, um Docker auf einem Linux-, Mac OS X- oder Windows-Computer zu verwenden. Als Umgebung wird Linux empfohlen.

Docker installieren

Installieren Sie Docker auf einem Betriebssystem Ihrer Wahl.

Docker-Image abrufen

Öffnen Sie nach der Installation von Docker ein Terminalfenster und rufen Sie das Docker-Image openthread/environment auf. Dieses Image zeigt eine vordefinierte und einsatzbereite OpenThread- und OpenThread-Daemon-Version für dieses Codelab.

$ docker pull openthread/environment:latest

Der Download kann einige Minuten dauern.

Starten Sie in einem Terminalfenster einen Docker-Container über das Image und stellen Sie eine Verbindung zur zugehörigen 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 Flags, die für dieses Codelab erforderlich sind:

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

Im Container sollte eine Aufforderung wie diese angezeigt werden:

root@c0f3912a74ff:/#

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

Docker verwenden

In diesem Codelab wird davon ausgegangen, dass Sie die Grundlagen von Docker kennen. Sie sollten das gesamte Codelab im Docker-Container ausführen.

3. Thread-Netzwerk simulieren

Die Beispielanwendung, die Sie für dieses Codelab verwenden, zeigt eine minimale OpenThread-Anwendung, die die OpenThread-Konfigurations- und -Verwaltungsschnittstellen über eine einfache Befehlszeilenschnittstelle verfügbar macht.

In dieser Übung werden die Mindestschritte beschrieben, die erforderlich sind, um ein emuliertes Thread-Gerät von einem anderen emulierten Thread-Gerät zu kontaktieren.

In der folgenden Abbildung wird eine grundlegende Thread-Netzwerktopologie beschrieben. Für diese Übung emulieren Sie die beiden Knoten im grünen Kreis: einen Thread-Leader und einen Thread-Router mit einer einzigen Verbindung zwischen ihnen.

6e3aa07675f902dc

Netzwerk erstellen

1. Knoten 1 starten

Wenn Sie dies noch nicht getan haben, starten Sie in einem Terminalfenster den Docker-Container und stellen Sie eine Verbindung zur zugehörigen 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

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

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

Hinweis: Wenn die Aufforderung > nach Ausführung dieses Befehls nicht zu sehen ist, drücken Sie enter.

Mit diesem Binärprogramm wird ein OpenThread-Gerät implementiert. Der IEEE 802.15.4-Radiotreiber wird als Teil von UDP implementiert (IEEE 802.15.4-Frames werden innerhalb von UDP-Nutzlasten übergeben).

Das Argument von 1 ist ein Dateideskriptor, der die niedrigstwertigen Bits des IEEE EUI-64 für das emulierte Gerät darstellt. Dieser Wert wird auch bei der Bindung an einen UDP-Port für die Funkemulation nach IEEE 802.15.4 verwendet (Port = 9000 + Dateideskriptor). Für jede Instanz eines emulierten Thread-Geräts in diesem Codelab wird ein anderer Dateideskriptor verwendet.

Hinweis: Verwenden Sie beim Erzeugen eines emulierten Geräts nur Dateideskriptoren mit einer Größe von 1 oder höher wie in diesem Codelab. Ein Dateideskriptor von 0 ist für eine andere Verwendung reserviert.

Erstellen Sie ein neues operatives Dataset und übernehmen Sie es als aktives Dataset. Das operative Dataset 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

Übernehmen Sie dieses Dataset als aktives Dataset:

> 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 zum Thread Leader geworden 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 Node 1 zugewiesen 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

Notieren Sie sich die spezifischen IPv6-Adresstypen:

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

Lokale Mesh-Netzwerkadressen werden weiter klassifiziert:

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

Notieren Sie sich die EID in der Konsolenausgabe, um sie später zu verwenden. In der obigen Beispielausgabe 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 für Knoten 2 aus.

$ docker exec -it codelab_otsim_ctnr bash

Erstellen Sie an dieser neuen bash-Eingabeaufforderung den Befehlszeilenprozess mit dem Argument 2. Dies ist Ihr zweites emuliertes Thread-Gerät:

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

Hinweis: Wenn die Aufforderung > nach Ausführung dieses Befehls nicht zu sehen ist, drücken Sie enter.

Konfigurieren Sie den Thread-Netzwerkschlüssel und die PAN mithilfe derselben Werte wie für das operative Dataset des Knotens 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Übernehmen Sie dieses Dataset als aktives Dataset:

> dataset commit active
Done

Rufen Sie die IPv6-Schnittstelle auf:

> ifconfig up
Done

Thread-Protokollvorgang starten:

> thread start
Done

Das Gerät initialisiert sich selbst als untergeordnetes Element. Ein untergeordnetes Thread-Element entspricht einem Endgerät. Das ist ein Thread-Gerät, das Unicast-Traffic nur mit einem übergeordneten Gerät überträgt und empfängt.

> state
child
Done

Innerhalb von 2 Minuten sollte der Status von child auf router wechseln. Ein Thread-Router kann Traffic zwischen Thread-Geräten weiterleiten. Sie wird auch als „übergeordnete Person“ bezeichnet.

> state
router
Done

Netzwerk überprüfen

Eine einfache Überprüfung des Mesh-Netzwerks finden Sie in der Routertabelle.

1. Verbindung prüfen

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

> rloc16
5800
Done

Prüfen Sie in Knoten 1 die Routertabelle auf RLOC16 von Knoten 2. Achten Sie darauf, dass zuerst Knoten 2 in den Routerstatus gewechselt ist.

> 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 von Knoten 2 befindet sich in der Tabelle und bestätigt, dass er mit dem Mesh verbunden ist.

2. Knoten 1 von Knoten 2 kontaktieren

Prüfen Sie die Verbindung zwischen den beiden emulierten Thread-Geräten. In Knoten 2, pingdie EID, 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 von > zurückzukehren.

Netzwerk testen

Da Sie jetzt erfolgreich zwischen zwei emulierten Thread-Geräten pingen können, testen Sie das Mesh-Netzwerk, indem Sie einen Knoten offline schalten.

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 Node 2, dass der Leader (Node 1) offline ist. Daher sollte für den Knoten 2 der Übergang leader des Netzwerks angezeigt werden:

> state
router
Done
...
> state
leader
Done

Beenden Sie dann den Thread und setzen Sie Knoten 2 auf die Werkseinstellungen zurück, bevor Sie die Docker-Eingabeaufforderung bash verlassen. Durch das Zurücksetzen auf die Werkseinstellungen wird sichergestellt, dass die in dieser Übung verwendeten Thread-Netzwerkanmeldedaten nicht für die nächste Übung übernommen werden.

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

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

Knoten auf Werkseinstellungen zurücksetzen und Knoten 1 beenden:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Informationen zu allen verfügbaren CLI-Befehlen finden Sie in der Referenz zu OpenThread CLI.

4. Knoten mit Inbetriebnahme authentifizieren

In der vorherigen Übung haben Sie ein Thread-Netzwerk mit zwei simulierten Geräten und verifizierter Konnektivität eingerichtet. Dadurch wird jedoch nur nicht authentifizierter lokaler IPv6-Link-Traffic zwischen Geräten zugelassen. 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 Provisionsmitglied tätig werden. Der Beauftragte ist der momentan ausgewählte Authentifizierungsserver für neue Thread-Geräte und der Autorisierer für die Angabe der Netzwerkanmeldedaten, die für die Verbindung mit den Geräten erforderlich sind.

In dieser Übung verwenden wir die gleiche Topologie mit zwei Knoten wie zuvor. Zur Authentifizierung fungiert der Thread Leader als Commissioner, der Thread Router als Joiner.

d6a67e8a0d0b5dcb.png

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 innerhalb desselben Docker-Containers noch zwei bash-Aufforderungen geöffnet sein. Ist dies nicht der Fall, lesen Sie den Schritt Docker-Fehlerbehebung oder wiederholen Sie einfach die Übung Thread-Netzwerk simulieren.

1. Netzwerk erstellen

Erstellen Sie in Knoten 1 den Befehlszeilenprozess:

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

Hinweis: Wenn die Aufforderung > nach Ausführung dieses Befehls nicht zu sehen ist, drücken Sie enter.

Erstellen Sie ein neues operatives Dataset, führen Sie ein Commit als aktives Dataset 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

Übernehmen Sie dieses Dataset als aktives Dataset:

> 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 ein Thread Leader ist:

> state
leader
Done

2. Die Rolle „Beauftragter“ starten

Starten Sie die Rolle „Provisionen“ noch in Knoten 1:

> commissioner start
Done

Zulassen, dass jeder Joiner (mit dem Platzhalter *) mit den J01NME-Teilnahmeinformationen für das Netzwerk eine Provision erhält. Ein Joiner ist ein Gerät, das von einem menschlichen Administrator zu einem in Auftrag gegebenen Thread-Netzwerk hinzugefügt wird.

> commissioner joiner add * J01NME
Done

3. Joiner-Rolle starten

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

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

Aktivieren Sie auf Knoten 2 die Joiner-Rolle mit den J01NME-Join-Anmeldedaten.

> ifconfig up
Done
> joiner start J01NME
Done

... warte einige Sekunden auf die Bestätigung ...

Join success

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

Nachdem Knoten 2 nun authentifiziert ist, starten Sie den Thread:

> thread start
Done

4. Netzwerkauthentifizierung validieren

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

> state
child
Done
...
> state
router
Done

5. Konfiguration zurücksetzen

Setzen Sie die Konfiguration zurück, um sich auf die nächste Übung vorzubereiten. Beenden Sie auf jedem Knoten den Thread, setzen Sie ihn 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 einige Male enter drücken, um die >-Eingabeaufforderung nach einem factoryreset-Befehl wiederherzustellen.

5. Netzwerk mit OpenThread Daemon verwalten

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

ot-daemon ist ein Modus der OpenThread Posix-Anwendung, der einen UNIX-Socket als Eingabe und Ausgabe verwendet, sodass der OpenThread-Kern als Dienst ausgeführt werden kann. Ein Client kann mit diesem Dienst kommunizieren, indem er über die OpenThread-Befehlszeile als Protokoll eine Verbindung zum Socket herstellt.

ot-ctl ist eine von ot-daemon bereitgestellte Befehlszeile zum Verwalten und Konfigurieren des RCP. Dadurch wird der RCP mit dem Netzwerk verbunden, 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 innerhalb desselben Docker-Containers zwei bash-Aufforderungen geöffnet sein. Falls nicht, lesen Sie den Schritt Docker-Fehlerbehebung.

Ot-Dämon verwenden

In dieser Übung werden drei Terminalfenster verwendet, die ungefähr so aussehen:

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

1. Knoten 1 starten

Erstellen Sie im ersten Terminalfenster den CLI-Prozess für Ihr emuliertes Thread-Gerät:

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

Hinweis: Wenn die Aufforderung > nach Ausführung dieses Befehls nicht zu sehen ist, drücken Sie enter.

Erstellen Sie ein neues operatives Dataset, führen Sie ein Commit als aktives Dataset 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

Übernehmen Sie dieses Dataset als aktives Dataset:

> 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 Node 1 zugewiesen sind:

> 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-Netzwerk simulieren erläutert, ist eine Adresse link-local (fe80) und drei eine Mesh-Local-Adresse (fd). Die EID ist die lokale Mesh-Adresse, die ff:fe00 in der Adresse nicht enthält. In dieser Beispielausgabe lautet die EID fd55:cf34:dea5:7994:460:872c:e807:c4ab.

Bestimmen 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 Terminalfenster 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 für die Übertragung und den Empfang von Paketen auf virtuellen Geräten verwendet. Wenn das Gerät bereits erstellt wurde, sehen Sie möglicherweise eine Fehlermeldung. 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 Flag -v, 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 eine Ausgabe wie diese:

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 im Hintergrund geöffnet. Sie müssen keine weiteren Befehle eingeben.

3. ot-ctl verwenden, um dem Netzwerk beizutreten

Knoten 2 (ot-daemon RCP) wurde noch in keinem Thread-Netzwerk in Betrieb genommen. Hier kommt ot-ctl ins Spiel. ot-ctl verwendet dieselbe Befehlszeile wie die OpenThread-CLI-App. Daher können Sie ot-daemon-Knoten auf dieselbe Weise steuern wie die anderen simulierten Thread-Geräte.

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

$ docker exec -it codelab_otsim_ctnr bash

Starten Sie ot-ctl im Container:

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

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

> state
disabled
Done

Rufen Sie Knoten 2 von eui64 ab, um die Verbindung mit dem spezifischen Joiner zu beschränken:

> eui64
18b4300000000001
Done

Starten Sie den Kommissar auf Node 1 (erstes Terminalfenster) und beschränken Sie den Beitritt auf diese eui64:

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

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

> ifconfig up
Done
> joiner start J01NME
Done

... warte einige Sekunden auf die Bestätigung ...

Join success

Als Joiner hat sich der RCP (Knoten 2) erfolgreich mit dem Kommissar (Knoten 1) authentifiziert und die Anmeldedaten für das Thread-Netzwerk erhalten.

Verknüpfen Sie nun Knoten 2 mit dem Thread-Netzwerk (im dritten Terminalfenster):

> thread start
Done

4. Netzwerkauthentifizierung validieren

Prüfen Sie im dritten Terminal das state auf Knoten 2, um zu prüfen, ob es sich nun mit dem Netzwerk verbunden hat. Innerhalb von zwei Minuten wechselt Knoten 2 von child zu router:

> state
child
Done
...
> state
router
Done

5. Verbindung prüfen

Beenden Sie ot-ctl im dritten Terminalfenster mit dem Befehl Strg + D oder exit und kehren Sie zur bash-Konsole des Containers zurück. Pingen Sie von dieser Konsole aus Knoten 1 mit seiner EID mit dem Befehl ping6. Wenn die RCP-Instanz ot-daemon verbunden wurde und mit dem Thread-Netzwerk 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 verlassen haben:

bash Aufforderungen angezeigt werden, müssen Sie möglicherweise prüfen, ob sie ausgeführt werden, und sie bei Bedarf neu starten.

So sehen Sie, welche Docker-Container ausgeführt werden:

$ 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 beendeten 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 Sie den Container codelab_otsim_ctnr in der Ausgabe eines der Befehle docker ps nicht sehen, 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 gestoppt wurde (in docker ps -a aufgelistet, aber nicht in docker ps), starten Sie ihn neu:

$ docker start -i codelab_otsim_ctnr

Wenn der Docker-Container bereits ausgeführt wird (in docker ps aufgeführt), stellen Sie die Verbindung zum Container in jedem Terminal wieder her:

$ docker exec -it codelab_otsim_ctnr bash

Fehler "Vorgang nicht zulässig"

Wenn beim Erstellen neuer OpenThread-Knoten (mit dem Befehl mknod) Fehler des Typs Operation not permitted auftreten, müssen Sie Docker als Root-Nutzer entsprechend den Befehlen in diesem Codelab ausführen. Dieses Codelab unterstützt nicht die Ausführung von Docker im Root-Modus.

7. Glückwunsch!

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

In diesem Codelab haben Sie Folgendes gelernt:

  • 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 in diesen Referenzen:

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