Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Simulation d'un réseau Thread à l'aide d'OpenThread dans Docker

26b7f4f6b3ea0700.png

OpenThread publié par Google est une implémentation open-source du protocole de mise en réseau Thread . Google Nest a lancé OpenThread pour rendre la technologie utilisée dans les produits Nest largement accessible aux développeurs afin d'accélérer le développement de produits pour la maison connectée.

La spécification Thread définit un protocole de communication appareil à appareil sans fil fiable, sécurisé et de faible puissance basé sur IPv6 pour les applications domestiques. OpenThread implémente toutes les couches de réseau Thread, y compris IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens maillés et routage maillé.

Ce Codelab vous guidera tout au long de la simulation d'un réseau Thread sur des appareils émulés à l'aide de Docker.

Ce que tu apprendras

  • Comment configurer la chaîne d'outils de construction OpenThread
  • Comment simuler un réseau Thread
  • Comment authentifier les nœuds de thread
  • Comment gérer un réseau Thread avec OpenThread Daemon

Ce dont vous aurez besoin

  • Docker
  • Connaissance de base de Linux, routage réseau

Ce Codelab est conçu pour utiliser Docker sur une machine Linux, Mac OS X ou Windows. Linux est l'environnement recommandé.

Installer Docker

Installez Docker sur le système d'exploitation de votre choix.

Télécharger Docker

Tirez l'image Docker

Une fois Docker installé, ouvrez une fenêtre de terminal et tirez l'image Docker openthread/codelab_otsim . Cette image présente OpenThread et OpenThread Daemon pré-construits et prêts à être utilisés pour ce Codelab.

$ docker pull openthread/codelab_otsim:latest

Notez que le téléchargement complet peut prendre quelques minutes.

Dans une fenêtre de terminal, démarrez un conteneur Docker à partir de l'image et connectez-vous à son shell bash :

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

Notez les indicateurs, qui sont requis pour ce Codelab:

  • --sysctl net.ipv6.conf.all.disable_ipv6=0 - cela active IPv6 dans le conteneur
  • --cap-add=net_admin - active la capacité NET_ADMIN, qui vous permet d'exécuter des opérations liées au réseau, telles que l'ajout de routes IP

Une fois dans le conteneur, vous devriez avoir une invite similaire à celle-ci:

root@c0f3912a74ff:/#

Dans l'exemple ci-dessus, le c0f3912a74ff est l'ID du conteneur. L'ID de conteneur de votre instance du conteneur Docker sera différent de celui affiché dans les invites de ce Codelab.

Utilisation de Docker

Ce Codelab suppose que vous connaissez les bases de l'utilisation de Docker. Vous devez rester dans le conteneur Docker pour l'intégralité du Codelab.

L'exemple d'application que vous utiliserez pour ce Codelab illustre une application OpenThread minimale qui expose la configuration d'OpenThread et les interfaces de gestion via une interface de ligne de commande (CLI) de base.

Cet exercice vous guide à travers les étapes minimales requises pour envoyer une requête ping à un périphérique Thread émulé à partir d'un autre périphérique Thread émulé.

La figure ci-dessous décrit une topologie de réseau Thread de base. Pour cet exercice, nous émulerons les deux nœuds dans le cercle vert: un Thread Leader et un Thread Router avec une seule connexion entre eux.

6e3aa07675f902dc.png

Créer le réseau

1. Démarrez le nœud 1

Si vous ne l'avez pas déjà fait, dans une fenêtre de terminal, démarrez le conteneur Docker et connectez-vous à son shell bash :

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

Dans le conteneur Docker, accédez au répertoire openthread et openthread le processus CLI pour un périphérique Thread émulé à l'aide du binaire ot-cli-ftd .

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Ce binaire implémente un périphérique OpenThread émulé au-dessus de POSIX. Le pilote radio IEEE 802.15.4 est implémenté au-dessus d'UDP (les trames IEEE 802.15.4 sont transmises dans les charges utiles UDP).

L'argument de 1 est un descripteur de fichier qui représente les bits les moins significatifs de l'IEEE EUI-64 «assignée en usine» pour le périphérique émulé. Cette valeur est également utilisée lors de la liaison à un port UDP pour l'émulation radio IEEE 802.15.4 (port = 9000 + descripteur de fichier). Chaque instance d'un périphérique Thread émulé dans ce Codelab utilisera un descripteur de fichier différent.

Remarque: utilisez uniquement des descripteurs de fichier de 1 ou plus, comme indiqué dans ce laboratoire de codes, lors de la création du processus pour un périphérique émulé. Un descripteur de fichier de 0 est réservé pour une autre utilisation.

Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .

Créez un nouvel ensemble de données opérationnelles et validez-le comme étant actif. Le jeu de données opérationnel est la configuration du réseau Thread que vous créez.

> 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
Master Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Validez cet ensemble de données en tant qu'actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrez le fonctionnement du protocole Thread:

> thread start
Done

Attendez quelques secondes et vérifiez que l'appareil est devenu le Thread Leader. Le leader est l'appareil responsable de la gestion de l'attribution des ID de routeur.

> state
leader
Done

Affichez les adresses IPv6 attribuées à l'interface Thread du nœud 1 (votre sortie sera différente):

> 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

Notez les types d'adresses IPv6 spécifiques:

  • Commence par fd = mesh-local
  • Commence par fe80 = link-local

Les types d'adresses locales de maillage sont classés plus en détail:

  • Contient ff:fe00 = Router Locator (RLOC)
  • Ne contient pas ff:fe00 = Endpoint Identifier (EID)

Identifiez l'EID dans la sortie de votre console, notez-le pour une utilisation ultérieure. Dans l'exemple de sortie ci-dessus, l'EID est:

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

2. Démarrez le nœud 2

Ouvrez un nouveau terminal et exécutez un shell bash dans le conteneur Docker en cours d'exécution à utiliser pour Node 2.

$ docker exec -it codelab_otsim_ctnr bash

À cette nouvelle invite bash , accédez au répertoire openthread et openthread le processus CLI. Ceci est votre deuxième appareil Thread émulé:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .

Configurez la clé principale de thread et l'ID PAN, en utilisant les mêmes valeurs que le jeu de données opérationnel du nœud 1:

> dataset masterkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Validez cet ensemble de données en tant qu'actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrez le fonctionnement du protocole Thread:

> thread start
Done

L'appareil s'initialise en tant qu'enfant. Un Thread Child équivaut à un End Device, qui est un Thread qui transmet et reçoit le trafic de monodiffusion uniquement avec un appareil Parent.

> state
child
Done

Dans les 2 minutes, vous devriez voir l'état passer de l' child au router . Un Thread Router est capable de router le trafic entre les périphériques Thread. Il est également appelé parent.

> state
router
Done

Vérifiez le réseau

Un moyen simple de vérifier le réseau maillé est de consulter le tableau des routeurs.

1. Vérifiez la connectivité

Sur le nœud 2, récupérez le RLOC16. Le RLOC16 correspond aux 16 derniers bits de l'adresse IPv6 RLOC de l'appareil.

> rloc16
5800
Done

Sur le nœud 1, vérifiez la table des routeurs pour le RLOC16 du nœud 2. Assurez-vous que le nœud 2 est d'abord passé à l'état du routeur.

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

Le RLOC du nœud 2 de 0x5800 se trouve dans le tableau, confirmant qu'il est connecté au maillage.

2. Ping Node 1 depuis Node 2

Vérifiez la connectivité entre les deux périphériques Thread émulés. Dans le nœud 2, ping une requête ping l’EID attribué au nœud 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

Appuyez sur enter pour revenir à l'invite > CLI.

Tester le réseau

Maintenant que vous pouvez exécuter un ping entre deux périphériques Thread émulés, testez le réseau maillé en mettant un nœud hors ligne.

Revenez au nœud 1 et arrêtez Thread:

> thread stop
Done

Basculez vers le nœud 2 et vérifiez l'état. En moins de deux minutes, le nœud 2 détecte que le leader (nœud 1) est hors ligne et vous devriez voir la transition du nœud 2 pour être le leader du réseau:

> state
router
Done
...
> state
leader
Done

Une fois confirmé, arrêtez Thread et réinitialisez le nœud 2 avant de revenir à l'invite Docker bash . Une réinitialisation d'usine est effectuée pour garantir que les informations d'identification du réseau Thread que nous avons utilisées dans cet exercice ne sont pas reportées à l'exercice suivant.

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

Vous devrez peut-être appuyer plusieurs fois sur enter pour ramener l'invite > après une commande de factoryreset . Ne quittez pas le conteneur Docker.

Également réinitialisé aux paramètres d'usine et quitter le nœud 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Consultez la référence de la CLI OpenThread pour explorer toutes les commandes CLI disponibles.

Dans l'exercice précédent, vous avez configuré un réseau Thread avec deux appareils simulés et une connectivité vérifiée. Cependant, cela permet uniquement au trafic lien-local IPv6 non authentifié de passer entre les appareils. Pour acheminer le trafic IPv6 global entre eux (et Internet via un routeur frontière Thread), les nœuds doivent être authentifiés.

Afin de s'authentifier, un appareil doit agir en tant que commissaire. Le commissaire est le serveur d'authentification actuellement élu pour les nouveaux appareils Thread et l'autorisateur pour fournir les informations d'identification réseau requises pour que les appareils rejoignent le réseau.

Dans cet exercice, nous utiliserons la même topologie à deux nœuds qu'auparavant. Pour l'authentification, le Thread Leader agira en tant que Commissaire, le Thread Router en tant que Joiner.

d6a67e8a0d0b5dcb.png

Docker

Pour chaque nœud (fenêtre de terminal) dans les exercices restants, assurez-vous que vous exécutez le conteneur Docker avec la version OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez toujours avoir deux invites bash dans le même conteneur Docker déjà ouvertes. Sinon, reportez-vous à l'étape de dépannage de Docker ou recommencez simplement l'exercice Simulate a Thread network .

1. Créez un réseau

Dans le nœud 1, lancez le processus CLI:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .

Créez un nouvel ensemble de données opérationnelles, validez-le comme étant actif et démarrez 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
Master Key: a77fe1d03b0e8028a4e13213de38080e
Network Name: OpenThread-8f37
PAN ID: 0x8f37
PSKc: f9debbc1532487984b17f92cd55b21fc
Security Policy: 0, onrcb
Done

Validez cet ensemble de données en tant qu'actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrez le fonctionnement du protocole Thread:

> thread start
Done

Attendez quelques secondes et vérifiez que l'appareil est devenu un Thread Leader:

> state
leader
Done

2. Commencer le rôle de commissaire

Tout en restant sur le nœud 1, démarrez le rôle de commissaire:

> commissioner start
Done

Autorisez n'importe quel Joiner (en utilisant le caractère générique * ) avec le J01NME Joiner Credential à mettre en service sur le réseau. Un Joiner est un appareil ajouté par un administrateur humain à un Thread Network commandé.

> commissioner joiner add * J01NME
Done

3. Démarrez le rôle Joiner

Dans une deuxième fenêtre de terminal, dans le conteneur Docker, créez un nouveau processus CLI. Il s'agit du nœud 2.

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

Sur le nœud 2, activez le rôle Joiner à l'aide des J01NME identification J01NME Joiner.

> ifconfig up
Done
> joiner start J01NME
Done

... attendez quelques secondes pour confirmation ...

Join success

En tant que Joiner, l'appareil (Nœud 2) s'est authentifié avec succès auprès du Commissaire (Nœud 1) et a reçu les informations d'identification de Thread Network.

Maintenant que le nœud 2 est authentifié, démarrez Thread:

> thread start
Done

4. Validez l'authentification réseau

Vérifiez l' state sur le nœud 2, pour valider qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de l' child au router :

> state
child
Done
...
> state
router
Done

5. Réinitialiser la configuration

Pour vous préparer à l'exercice suivant, réinitialisez la configuration. Sur chaque nœud, arrêtez Thread, effectuez une réinitialisation d'usine et quittez le périphérique Thread émulé:

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

Vous devrez peut-être appuyer sur enter plusieurs fois pour ramener l'invite > après une commande de factoryreset .

Pour cet exercice, nous allons simuler une instance CLI (un seul périphérique SoC Thread intégré) et une instance de Radio Co-Processor (RCP).

ot-daemon est un mode de l'application OpenThread Posix qui utilise un socket UNIX comme entrée et sortie, afin que OpenThread core puisse s'exécuter en tant que service. Un client peut communiquer avec ce service en se connectant au socket en utilisant l'interface de ligne de commande OpenThread comme protocole.

ot-ctl est une CLI fournie par ot-daemon pour gérer et configurer le RCP. En utilisant cela, nous connecterons le RCP au réseau créé par le périphérique Thread.

Docker

Pour chaque nœud (fenêtre de terminal) de cet exercice, assurez-vous que vous exécutez le conteneur Docker avec la version OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez avoir deux invites bash dans le même conteneur Docker déjà ouvertes. Sinon, reportez-vous à l'étape de dépannage de Docker .

Utilisez ot-daemon

Cet exercice utilisera trois fenêtres de terminal, correspondant à ce qui suit:

  1. Instance CLI du périphérique Thread simulé (Nœud 1)
  2. processus ot-daemon
  3. Instance CLI ot-ctl

1. Démarrez le nœud 1

Dans la première fenêtre de terminal, lancez le processus CLI pour votre périphérique Thread émulé:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Si vous ne voyez pas l' invite > après avoir exécuté cette commande, appuyez sur enter .

Créez un nouvel ensemble de données opérationnelles, validez-le comme étant actif et démarrez 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
Master Key: ba6e886c7af50598df1115fa07658a83
Network Name: OpenThread-34e4
PAN ID: 0x34e4
PSKc: 38d6fd32c866927a4dfcc06d79ae1192
Security Policy: 0, onrcb
Done

Validez cet ensemble de données en tant qu'actif:

> dataset commit active
Done

Affichez l'interface IPv6:

> ifconfig up
Done

Démarrez le fonctionnement du protocole Thread:

> thread start
Done

Affichez les adresses IPv6 attribuées à l'interface Thread du nœud 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
>

Comme expliqué dans l'étape Simuler un réseau Thread , une adresse est link-local ( fe80 ) et trois sont mesh-local ( fd ). L'EID est l'adresse locale du maillage qui ne contient pas ff:fe00 dans l'adresse. Dans cet exemple de sortie, l'EID est fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identifiez l'EID spécifique de votre sortie ipaddr , qui sera utilisé pour communiquer avec le nœud.

2. Démarrez ot-daemon

Dans la deuxième fenêtre de terminal, créez un nœud de périphérique tun et définissez les autorisations de lecture / écriture:

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

Cet appareil est utilisé pour la transmission et la réception de paquets dans des appareils virtuels. Vous pouvez obtenir une erreur si le périphérique a déjà été créé. Ceci est normal et peut être ignoré.

Accédez au répertoire openthread et démarrez ot-daemon pour un nœud RCP, que nous appellerons Node 2. Utilisez l'indicateur détaillé -v pour voir la sortie du journal et confirmer son exécution:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-daemon -v \
    'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'

En cas de succès, ot-daemon en mode détaillé génère une sortie similaire à ce qui suit:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun 7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun 7 2020 18:06:08

3. Utilisez ot-ctl pour rejoindre le réseau

Nous n'avons pas encore mis en service Node 2 (le RCP ot-daemon ) sur un réseau Thread. C'est là ot-ctl vient. ot-ctl utilise la même CLI que l'application OpenThread CLI. Par conséquent, vous pouvez contrôler les nœuds ot-daemon de la même manière que les autres périphériques Thread simulés.

Ouvrez une troisième fenêtre de terminal et exécutez le conteneur existant:

$ docker exec -it codelab_otsim_ctnr bash

Une fois dans le conteneur, lancez ot-ctl :

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-ctl
>

Vérifiez l' state du nœud 2 (le nœud RCP) que vous avez démarré avec ot-daemon :

> state
disabled
Done

Obtenez l' eui64 Node 2 pour restreindre l'adhésion au Joiner spécifique:

> eui64
18b4300000000001
Done

Sur le nœud 1, démarrez le commissaire et limitez l'adhésion à seulement cet eui64:

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

Sur le nœud 2, affichez l'interface réseau et rejoignez le réseau:

> ifconfig up
Done
> joiner start J01NME
Done

... attendez quelques secondes pour confirmation ...

Join success

En tant que Joiner, le RCP (Node 2) s'est authentifié avec succès auprès du Commissaire (Node 1) et a reçu les informations d'identification du Thread Network.

Rejoignez maintenant Node 2 sur le réseau Thread:

> thread start
Done

4. Validez l'authentification réseau

Vérifiez l' state sur le nœud 2, pour valider qu'il a maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de l' child au router :

> state
child
Done
...
> state
router
Done

5. Validez la connectivité

Quittez ot-ctl en utilisant Ctrl + D et sur la ligne de commande de votre machine hôte, ping6 ping au nœud 1, en utilisant son EID avec la commande ping6 . Si l'instance RCP ot-daemon est correctement jointe et communique avec le réseau Thread, le ping réussit:

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

Si vous avez quitté les invites de bash conteneur Docker , vous devrez peut-être vérifier s'il est en cours d'exécution et redémarrer / ressaisir si nécessaire.

Pour afficher les conteneurs Docker en cours d'exécution:

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

Pour afficher tous les conteneurs Docker (en cours d'exécution et arrêtés):

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

Si vous ne voyez pas le conteneur codelab_otsim_ctnr dans la sortie de l'une ou l'autre des commandes docker ps , exécutez-le à nouveau:

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

Si le conteneur est arrêté (répertorié dans docker ps -a mais pas docker ps ), redémarrez-le:

$ docker start -i codelab_otsim_ctnr

Si le conteneur Docker est déjà en cours d'exécution (répertorié dans docker ps ), reconnectez-vous au conteneur dans chaque terminal:

$ docker exec -it codelab_otsim_ctnr bash

Vous avez simulé avec succès votre premier réseau Thread à l'aide d'OpenThread. Impressionnant!

Dans ce Codelab, vous avez appris à:

  • Démarrez et gérez le conteneur Docker OpenThread Simulation
  • Simuler un réseau Thread
  • Authentifier les nœuds de thread
  • Gérer un réseau Thread avec OpenThread Daemon

Pour en savoir plus sur Thread et OpenThread, explorez ces références:

Ou essayez d'utiliser OpenThread Border Router dans un conteneur Docker !