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

1. Introduction

OpenThread, publié par Google, est une implémentation Open Source du protocole réseau Thread. Google Nest a publié OpenThread pour mettre la technologie utilisée dans les produits Nest à la disposition des 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 sans fil fiable, sécurisé et basse consommation basé sur IPv6 pour les applications domotiques. OpenThread implémente toutes les couches réseau Thread, y compris IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens Mesh et routage Mesh.

Cet atelier de programmation vous explique comment simuler un réseau Thread sur des appareils émulés à l'aide de Docker.

Points abordés

Configurer la chaîne d'outils de compilation OpenThread
Simuler un réseau Thread
Authentifier les nœuds Thread
Gérer un réseau Thread avec OpenThread Daemon

Prérequis

Docker
Connaissances de base de Linux et du routage réseau

2. Configurer Docker

Cet atelier de programmation 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 l'OS de votre choix.

Extraire l'image Docker

Une fois Docker installé, ouvrez une fenêtre de terminal et extrayez l'image Docker openthread/environment. Cette image contient OpenThread et OpenThread Daemon précompilés et prêts à être utilisés pour cet atelier de programmation.

$ docker pull openthread/environment: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/environment bash

L'option --rm supprime le conteneur lorsque vous le quittez. N'utilisez pas cette option si vous ne souhaitez pas que le conteneur soit supprimé.

Notez les indicateurs, qui sont obligatoires pour cet atelier de programmation :

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

Une fois dans le conteneur, vous devriez obtenir une invite semblable à celle-ci :

root@c0f3912a74ff:/#

Dans l'exemple ci-dessus, c0f3912a74ff correspond à l'ID du conteneur. L'ID de conteneur de votre instance de conteneur Docker sera différent de celui indiqué dans les invites de cet atelier de programmation.

Utiliser Docker

Cet atelier de programmation suppose que vous connaissez les bases de l'utilisation de Docker. Vous devez rester dans le conteneur Docker pendant toute la durée de l'atelier de programmation.

3. Simuler un réseau Thread

L'exemple d'application que vous utiliserez pour cet atelier de programmation présente une application OpenThread minimale qui expose les interfaces de configuration et de gestion OpenThread via une interface de ligne de commande (CLI) de base.

Cet exercice vous guide à travers les étapes minimales requises pour envoyer un ping d'un appareil Thread émulé à un autre appareil Thread émulé.

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

Créer le réseau à l'aide de la commande suivante

1. Nœud de départ 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/environment bash

Dans le conteneur Docker, lancez le processus CLI pour un appareil Thread émulé à l'aide du binaire ot-cli-ftd.

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

Remarque : Si l'invite > ne s'affiche pas après l'exécution de cette commande, appuyez sur enter.

Ce binaire implémente un appareil OpenThread. 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 "attribué en usine" pour l'appareil é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 appareil Thread émulé dans cet atelier de programmation utilisera un descripteur de fichier différent.

Remarque : N'utilisez que des descripteurs de fichier 1 ou supérieur, comme indiqué dans cet atelier de programmation, lorsque vous générez le processus pour un appareil émulé. Un descripteur de fichier 0 est réservé à d'autres utilisations.

Créez un ensemble de données opérationnelles et définissez-le comme actif. L'ensemble de données opérationnelles correspond à 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
Network Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Validez cet ensemble de données comme actif :

> dataset commit active
Done

Activez l'interface IPv6 :

> ifconfig up
Done

Démarrer l'opération du protocole Thread :

> thread start
Done

Attendez quelques secondes, puis vérifiez que l'appareil est devenu le leader Thread. Le leader est l'appareil chargé de gérer l'attribution des ID de routeur.

> state
leader
Done

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

> 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 = liaison locale

Les types d'adresses locales au réseau maillé sont classés comme suit :

Contient ff:fe00 = Router Locator (RLOC)
Ne contient pas ff:fe00 = identifiant du point de terminaison (EID)

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

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

2. Démarrer le nœud 2

Ouvrez un nouveau terminal et exécutez un shell bash dans le conteneur Docker en cours d'exécution pour l'utiliser avec le nœud 2.

$ docker exec -it codelab_otsim_ctnr bash

À ce nouveau prompt bash, lancez le processus CLI avec l'argument 2. Voici votre deuxième appareil Thread émulé :

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

Remarque : Si l'invite > ne s'affiche pas après l'exécution de cette commande, appuyez sur enter.

Configurez la clé du réseau Thread et l'ID PAN en utilisant les mêmes valeurs que celles de l'ensemble de données opérationnelles du nœud 1 :

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Validez cet ensemble de données comme actif :

> dataset commit active
Done

Activez l'interface IPv6 :

> ifconfig up
Done

Démarrer l'opération du protocole Thread :

> thread start
Done

L'appareil s'initialise en tant qu'enfant. Un nœud enfant Thread équivaut à un appareil final, qui est un appareil Thread qui transmet et reçoit le trafic en monodiffusion uniquement avec un nœud parent.

> state
child
Done

Au bout de deux minutes, l'état devrait passer de child à router. Un routeur Thread est capable de router le trafic entre les appareils Thread. Il est également appelé "parent".

> state
router
Done

Vérifier le réseau

Pour vérifier facilement le réseau maillé, consultez la table de routage.

1. Vérifiez la connectivité

Sur le nœud 2, obtenez le RLOC16. 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 de routage pour le RLOC16 du nœud 2. Assurez-vous d'abord que le nœud 2 est passé à l'état de 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 0x5800 du nœud 2 figure dans le tableau, ce qui confirme qu'il est connecté au réseau maillé.

2. Pinguer le nœud 1 depuis le nœud 2

Vérifiez la connectivité entre les deux appareils Thread émulés. Dans le nœud 2, 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 de la CLI >.

Tester le réseau

Maintenant que vous pouvez effectuer un ping entre deux appareils Thread émulés, testez le réseau maillé en mettant un nœud hors connexion.

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

> thread stop
Done

Passez au nœud 2 et vérifiez l'état. Dans un délai de deux minutes, le nœud 2 détecte que le nœud principal (nœud 1) est hors connexion. Vous devriez voir le nœud 2 devenir le leader du réseau :

> state
router
Done
...
> state
leader
Done

Une fois la confirmation reçue, arrêtez Thread et rétablissez la configuration d'usine du nœud 2 avant de revenir à l'invite Docker bash. La réinitialisation des paramètres d'usine permet de s'assurer que les identifiants du réseau Thread que nous avons utilisés dans cet exercice ne sont pas conservés pour le prochain exercice.

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

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

Rétablissez également la configuration d'usine et quittez le nœud 1 :

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Consultez la documentation de référence sur la CLI OpenThread pour découvrir toutes les commandes de CLI disponibles.

4. Authentifier les nœuds avec la mise en service

Dans l'exercice précédent, vous avez configuré un réseau Thread avec deux appareils simulés et vérifié la connectivité. Toutefois, cela ne permet que le trafic IPv6 link-local non authentifié de transiter entre les appareils. Pour acheminer le trafic IPv6 global entre eux (et vers Internet via un routeur de bordure Thread), les nœuds doivent être authentifiés.

Pour s'authentifier, un appareil doit agir en tant que commissaire. Le commissaire est le serveur d'authentification actuellement élu pour les nouveaux appareils Thread. Il est également l'auteur de l'autorisation permettant de fournir les identifiants réseau nécessaires aux appareils pour rejoindre le réseau.

Dans cet exercice, nous allons utiliser la même topologie à deux nœuds que précédemment. Pour l'authentification, le leader Thread fera office de commissaire et le routeur Thread de participant.

Docker

Pour chaque nœud (fenêtre de terminal) des exercices restants, assurez-vous d'exécuter le conteneur Docker avec la compilation OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez toujours avoir deux invites bash ouvertes dans le même conteneur Docker. Si ce n'est pas le cas, consultez l'étape Dépannage Docker ou refaites simplement l'exercice Simuler un réseau Thread.

1. Créer un réseau

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

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

Remarque : Si l'invite > ne s'affiche pas après l'exécution de cette commande, appuyez sur enter.

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

Validez cet ensemble de données comme actif :

> dataset commit active
Done

Activez l'interface IPv6 :

> ifconfig up
Done

Démarrer l'opération du protocole Thread :

> thread start
Done

Attendez quelques secondes, puis vérifiez que l'appareil est devenu un leader Thread :

> state
leader
Done

2. Commencer avec le rôle de commissaire

Toujours sur le nœud 1, démarrez le rôle de commissaire :

> commissioner start
Done

Autorisez n'importe quel associé (en utilisant le caractère générique *) avec l'identifiant d'associé J01NME à mettre en service le réseau. Un Joiner est un appareil ajouté par un administrateur humain à un réseau Thread mis en service.

> commissioner joiner add * J01NME
Done

3. Démarrer le rôle de participant

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

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

Sur le nœud 2, activez le rôle "Joiner" (Joigneur) à l'aide de l'identifiant Joiner J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... patientez quelques secondes pour obtenir la confirmation ...

Join success

En tant que nœud participant, l'appareil (nœud 2) s'est authentifié auprès du commissaire (nœud 1) et a reçu les identifiants du réseau Thread.

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

> thread start
Done

4. Valider l'authentification réseau

Vérifiez le state sur le nœud 2 pour confirmer qu'il a rejoint le réseau. Au bout de deux minutes, le nœud 2 passe de child à router :

> state
child
Done
...
> state
router
Done

5. Réinitialiser la configuration

Pour préparer le prochain exercice, réinitialisez la configuration. Sur chaque nœud, arrêtez Thread, rétablissez la configuration d'usine et quittez l'appareil Thread émulé :

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

Vous devrez peut-être appuyer plusieurs fois sur enter pour faire réapparaître l'invite > après une commande factoryreset.

5. Gérer le réseau avec OpenThread Daemon

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

ot-daemon est un mode de l'application OpenThread POSIX qui utilise un socket UNIX comme entrée et sortie, afin que le cœur d'OpenThread puisse s'exécuter en tant que service. Un client peut communiquer avec ce service en se connectant au socket à l'aide de 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. Nous allons l'utiliser pour connecter le RCP au réseau créé par l'appareil Thread.

Docker

Pour chaque nœud (fenêtre de terminal) de cet exercice, assurez-vous d'exécuter le conteneur Docker avec la compilation OpenThread. Si vous continuez à partir de l'exercice précédent, vous devriez déjà avoir deux invites bash ouvertes dans le même conteneur Docker. Si ce n'est pas le cas, consultez l'étape Dépannage de Docker.

Utiliser ot-daemon

Cet exercice utilise trois fenêtres de terminal, correspondant aux éléments suivants :

Instance CLI de l'appareil Thread simulé (nœud 1)
Nœud de traitement ot-daemon
Instance de la CLI ot-ctl

1. Nœud de départ 1

Dans la première fenêtre de terminal, générez le processus CLI pour votre appareil Thread émulé :

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

Remarque : Si l'invite > ne s'affiche pas après l'exécution de cette commande, appuyez sur enter.

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

Validez cet ensemble de données comme actif :

> dataset commit active
Done

Activez l'interface IPv6 :

> ifconfig up
Done

Démarrer l'opération 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 de portée locale (fe80) et trois sont de portée réseau (fd). L'EID est l'adresse de portée réseau qui ne contient pas ff:fe00 dans l'adresse. Dans cet exemple de résultat, l'EID est fd55:cf34:dea5:7994:460:872c:e807:c4ab.

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

2. Démarrer 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 les appareils virtuels. Il est possible qu'une erreur s'affiche si l'appareil a déjà été créé. C'est normal et vous pouvez l'ignorer.

Démarrez ot-daemon pour un nœud RCP, que nous appellerons "Nœud 2". Utilisez l'option verbose -v pour afficher la sortie du journal et confirmer que le processus est en cours d'exécution :

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

Si l'opération réussit, ot-daemon en mode verbeux génère un résultat semblable à celui-ci :

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

Laissez ce terminal ouvert et en cours d'exécution en arrière-plan. Vous n'y saisirez aucune autre commande.

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

Nous n'avons pas encore mis en service le nœud 2 (le RCP ot-daemon) sur un réseau Thread. C'est là qu'intervient ot-ctl. ot-ctl utilise la même CLI que l'application OpenThread CLI. Vous pouvez donc contrôler les nœuds ot-daemon de la même manière que les autres appareils 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, démarrez ot-ctl :

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

Vous utiliserez ot-ctl dans cette troisième fenêtre de terminal pour gérer le nœud 2 (le nœud RCP) que vous avez démarré dans la deuxième fenêtre de terminal avec ot-daemon. Vérifiez le state du nœud 2 :

> state
disabled
Done

Obtenez le eui64 du nœud 2 pour limiter l'association à un Associateur spécifique :

> eui64
18b4300000000001
Done

Sur le nœud 1 (première fenêtre de terminal), démarrez le commissaire et limitez l'association à cet eui64 :

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

Dans la troisième fenêtre de terminal, affichez l'interface réseau du nœud 2 et rejoignez le réseau :

> ifconfig up
Done
> joiner start J01NME
Done

... patientez quelques secondes pour obtenir la confirmation ...

Join success

En tant que nœud participant, le RCP (nœud 2) s'est authentifié avec succès auprès du commissaire (nœud 1) et a reçu les identifiants du réseau Thread.

Associez maintenant le nœud 2 au réseau Thread (toujours dans la troisième fenêtre de terminal) :

> thread start
Done

4. Valider l'authentification réseau

Dans le troisième terminal, vérifiez le state sur le nœud 2 pour confirmer qu'il a rejoint le réseau. Au bout de deux minutes, le nœud 2 passe de child à router :

> state
child
Done
...
> state
router
Done

5. Valider la connectivité

Dans la troisième fenêtre de terminal, quittez ot-ctl en utilisant la commande Ctrl+D ou exit, puis revenez à la console bash du conteneur. À partir de cette console, envoyez un ping au nœud 1 en utilisant son EID avec la commande ping6. Si l'instance ot-daemon RCP a bien rejoint le réseau Thread et communique avec lui, 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

6. Dépannage de Docker

Si vous avez quitté le conteneur Docker

Si vous utilisez des bash invites, vous devrez peut-être vérifier si elles sont en cours d'exécution, puis les redémarrer ou les saisir à nouveau si nécessaire. Tous les conteneurs Docker que vous avez créés sans utiliser l'option --rm devraient toujours exister.

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

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "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        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Si le conteneur codelab_otsim_ctnr ne s'affiche pas dans le résultat de l'une des commandes docker ps, exécutez-la à nouveau :

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

N'utilisez l'option --rm que si vous souhaitez que le conteneur soit supprimé à la fermeture.

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

$ docker start -i codelab_otsim_ctnr

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

$ docker exec -it codelab_otsim_ctnr bash

Erreurs "Opération non autorisée"

Si vous rencontrez des erreurs Operation not permitted lors de la création de nœuds OpenThread (à l'aide de la commande mknod), assurez-vous d'exécuter Docker en tant qu'utilisateur racine, conformément aux commandes fournies dans cet atelier de programmation. Ce Codelab n'est pas compatible avec l'exécution de Docker en mode sans racine.

7. Félicitations !

Vous avez réussi à simuler votre premier réseau Thread à l'aide d'OpenThread. Formidable !

Dans cet atelier de programmation, vous avez appris à :

Démarrer et gérer le conteneur Docker de simulation OpenThread
Simuler un réseau Thread
Authentifier les nœuds Thread
Gérer un réseau Thread avec OpenThread Daemon

Pour en savoir plus sur Thread et OpenThread, consultez les références suivantes :

Vous pouvez également essayer d'utiliser OpenThread Border Router dans un conteneur Docker.

Simuler un réseau Thread à l'aide d'OpenThread dans Docker Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Introduction

Points abordés

Prérequis

2. Configurer Docker

Installer Docker

Extraire l'image Docker

Utiliser Docker

3. Simuler un réseau Thread

Créer le réseau à l'aide de la commande suivante

1. Nœud de départ 1

2. Démarrer le nœud 2

Vérifier le réseau

1. Vérifiez la connectivité

2. Pinguer le nœud 1 depuis le nœud 2

Tester le réseau

4. Authentifier les nœuds avec la mise en service

Docker

1. Créer un réseau

2. Commencer avec le rôle de commissaire

3. Démarrer le rôle de participant

4. Valider l'authentification réseau

5. Réinitialiser la configuration

5. Gérer le réseau avec OpenThread Daemon

Docker

Utiliser ot-daemon

1. Nœud de départ 1

2. Démarrer ot-daemon

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

4. Valider l'authentification réseau

5. Valider la connectivité

6. Dépannage de Docker

Erreurs "Opération non autorisée"

7. Félicitations !

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