1. Introduction
OpenThread publié par Google est une implémentation Open Source du protocole réseau Thread. Google Nest a lancé OpenThread afin de 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 sans fil d'appareil à appareil fiable, sécurisé et à faible consommation d'énergie basé sur IPv6 pour les applications domestiques. OpenThread implémente toutes les couches réseau Thread, y compris IPv6, 6LoWPAN, IEEE 802.15.4 avec sécurité MAC, établissement de liens maillés et routage maillé.
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 le daemon OpenThread
Prérequis
- Docker
- Connaissances de base de Linux, le routage réseau
2. Configurer Docker
Cet atelier de programmation est conçu pour utiliser Docker sur un ordinateur Linux, Mac OS X ou Windows. Nous vous recommandons d'utiliser l'environnement Linux.
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 présente OpenThread et le daemon OpenThread pré-construits et prêts à être utilisés pour cet atelier de programmation.
$ docker pull openthread/environment:latest
Notez que le téléchargement 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 options, qui sont requises pour cet atelier de programmation:
--sysctl net.ipv6.conf.all.disable_ipv6=0: active le protocole 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, une invite de ce type doit s'afficher:
root@c0f3912a74ff:/#
Dans l'exemple ci-dessus, c0f3912a74ff correspond à l'ID du conteneur. L'ID de conteneur de votre instance Docker sera différent de celui affiché dans les invites de cet atelier de programmation.
Utiliser Docker
Dans cet atelier de programmation, nous partons du principe que vous connaissez les principes de base 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 illustre 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 pinguer un appareil Thread émulé à partir d'un autre appareil Thread émulé.
La figure ci-dessous décrit une topologie de base d'un réseau Thread. Pour cet exercice, nous allons émuler les deux nœuds situés dans le cercle vert: un leader de thread et un routeur de thread avec une seule connexion entre eux.
Créer le réseau à l'aide de la commande suivante
1. Démarrer le nœud 1
Si vous ne l'avez pas déjà fait, démarrez le conteneur Docker dans une fenêtre de terminal 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, générez 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 vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.
Ce binaire implémente un périphérique OpenThread. Le pilote radio IEEE 802.15.4 est implémenté au-dessus de l'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 des "attribués par l'usine". IEEE EUI-64 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). Dans cet atelier de programmation, chaque instance d'un appareil Thread émulé utilise un descripteur de fichier différent.
Remarque:Utilisez uniquement des descripteurs de fichier de 1 ou d'une version ultérieure, 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érationnel et validez-le en tant qu'ensemble de données actif. L'ensemble de données opérationnel 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 en tant qu'ensemble de données actif:
> dataset commit active Done
Affichez 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 Thread Leader. Le responsable 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 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= lien-local
Les types d'adresses de réseau maillé local sont classés plus précisément:
- Contient
ff:fe00= outil de localisation de routeurs (RLOC) - Ne contient pas
ff:fe00= identifiant du point de terminaison (EID)
Identifiez l'EID dans la sortie de votre 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 une interface système bash dans le conteneur Docker en cours d'exécution à utiliser pour le nœud 2.
$ docker exec -it codelab_otsim_ctnr bash
À cette nouvelle invite bash, générez 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 vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.
Configurez la clé du réseau Thread et l'ID du PAN en utilisant les mêmes valeurs que l'ensemble de données opérationnel du nœud 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Validez cet ensemble de données en tant qu'ensemble de données actif:
> dataset commit active Done
Affichez 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 enfant Thread est équivalent à un appareil final, c'est-à-dire un périphérique Thread qui transmet et reçoit le trafic unicast uniquement avec un appareil parent.
> state child Done
Au bout de deux minutes, vous devriez voir l'état passer de child à router. Un routeur Thread est capable d'acheminer le trafic entre des appareils Thread. Elle est également appelée parent.
> state router Done
Vérifier le réseau
Pour vérifier facilement le réseau maillé, consultez la table du routeur.
1. Vérifier la connectivité
Sur le nœud 2, obtenez 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, consultez la table du routeur pour trouver le RLOC16 du nœud 2. Assurez-vous d'abord que le nœud 2 est 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 0x5800 du nœud 2 figure dans la table, ce qui confirme qu'il est connecté au maillage.
2. Pinguer le nœud 1 du 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 CLI >.
Tester le réseau
Maintenant que vous pouvez pinguer deux appareils Thread émulés entre eux, testez le réseau maillé en mettant un nœud hors connexion.
Revenez au nœud 1 et arrêtez le thread:
> thread stop Done
Passez au nœud 2 et vérifiez l'état. Au bout de deux minutes, le nœud 2 détecte que le nœud principal (nœud 1) est hors connexion. La transition du nœud 2 devrait donc apparaître en tant que leader du réseau:
> state router Done ... > state leader Done
Une fois que vous avez confirmé, arrêtez le thread et rétablissez la configuration d'usine du nœud 2 avant de revenir à l'invite Docker bash. Une restauration de la configuration d'usine est effectuée pour s'assurer que les identifiants du réseau Thread que nous avons utilisés dans cet exercice ne seront pas transférés vers l'exercice suivant.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Vous devrez peut-être appuyer sur enter plusieurs fois pour que l'invite > réapparaisse 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 de la CLI OpenThread pour explorer toutes les commandes 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 de simulation et vérifié la connectivité. Toutefois, cela n'autorise que le trafic de liaison locale IPv6 non authentifié à passer entre les appareils. Pour acheminer le trafic IPv6 global entre eux (et 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 Commissioner est le serveur d'authentification actuellement élu pour les nouveaux appareils Thread et l'agent d'autorisation qui fournit les identifiants réseau requis pour que les appareils puissent le rejoindre.
Dans cet exercice, nous allons utiliser la même topologie à deux nœuds qu'auparavant. Pour l'authentification, le leader de thread agira en tant que commissaire, le routeur de threads en tant que jointer.
Docker
Pour chaque nœud (fenêtre de terminal) des exercices restants, veillez à exécuter le conteneur Docker avec le build OpenThread. Si vous suivez l'exercice précédent, vous devriez toujours avoir deux invites bash déjà ouvertes dans le même conteneur Docker. Si ce n'est pas le cas, reportez-vous à l'étape Résolution des problèmes Docker ou recommencez simplement l'exercice Simuler un réseau Thread.
1. Créer un réseau
Dans le nœud 1, générez le processus CLI:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Remarque:Si vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.
Créez un ensemble de données opérationnel, validez-le en tant qu'ensemble de données actif, puis démarrez le 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 en tant qu'ensemble de données actif:
> dataset commit active Done
Affichez l'interface IPv6:
> ifconfig up Done
Démarrer l'opération du protocole Thread:
> thread start Done
Attendez quelques secondes et vérifiez que l'appareil est devenu Thread Leader:
> state leader Done
2. Démarrer le rôle de commissaire
Toujours sur le nœud 1, démarrez le rôle "Commissaire" :
> commissioner start Done
Autorisez toutes les jointures (en utilisant le caractère générique *) disposant de l'identifiant Joiner J01NME à être mise en service sur 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 Joiner
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 à l'aide des identifiants Joiner J01NME.
> ifconfig up Done > joiner start J01NME Done
... patientez quelques secondes pour confirmation ...
Join success
En tant que Joiner, l'appareil (Node 2) s'est authentifié auprès du Commissioner (Node 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 maintenant rejoint le réseau. En deux minutes, le nœud 2 passe de child à router:
> state child Done ... > state router Done
5. Réinitialiser la configuration
Pour préparer l'exercice suivant, réinitialisez la configuration. Sur chaque nœud, arrêtez le 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 sur enter plusieurs fois pour que l'invite > réapparaisse après une commande factoryreset.
5. Gérer le réseau avec le daemon OpenThread
Pour cet exercice, nous allons simuler une instance CLI (un seul appareil de thread SoC intégré) et une instance de co-processeur radio (RCP).
ot-daemon est un mode de l'application OpenThread Posix qui utilise un socket UNIX en entrée et en sortie, afin que le cœur OpenThread puisse s'exécuter en tant que service. Un client peut communiquer avec ce service en se connectant au socket en utilisant la CLI OpenThread comme protocole.
ot-ctl est une CLI fournie par ot-daemon pour gérer et configurer le RCP. À l'aide de cela, nous connecterons 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 le build OpenThread. Si vous suivez l'exercice précédent, vous devriez avoir deux invites bash déjà ouvertes dans le même conteneur Docker. Si ce n'est pas le cas, reportez-vous à l'étape Dépannage 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 CLI
ot-ctl
1. Démarrer le nœud 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 vous ne voyez pas l'invite > après avoir exécuté cette commande, appuyez sur enter.
Créez un ensemble de données opérationnel, validez-le en tant qu'ensemble de données actif, puis démarrez le 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 en tant qu'ensemble de données actif:
> dataset commit active Done
Affichez 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 type liaison locale (fe80) et trois sont de type réseau maillé (fd). L'EID est l'adresse du réseau maillé local dont l'adresse ne contient pas ff:fe00. Dans cet exemple de résultat, l'EID est fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Identifiez l'EID spécifique dans 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 d'appareil 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. Il est possible qu'un message d'erreur s'affiche si l'appareil a déjà été créé. Ce comportement est normal et peut être ignoré.
Démarrez ot-daemon pour un nœud RCP, que nous appellerons "Node 2". Utilisez l'indicateur de verbosité -v pour afficher la sortie du journal et vérifier qu'elle 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 détaillé 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 exécuté en arrière-plan. Vous n'y saisirez aucune autre commande.
3. Utiliser ot-ctl pour rejoindre le réseau
Nous n'avons encore mis en service le nœud 2 (le RCP ot-daemon) d'aucun réseau Thread. C'est là que ot-ctl entre en jeu. ot-ctl utilise la même CLI que l'application CLI OpenThread. Par conséquent, vous pouvez 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 allez utiliser 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 la jointure à la jointure spécifique:
> eui64 18b4300000000001 Done
Sur le nœud 1 (première fenêtre de terminal), démarrez le "Commissioner" et limitez la jointure à cette interface utilisateur:
> 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 confirmation ...
Join success
En tant que Joiner, le RCP (Node 2) s'est authentifié avec le Commissaire (Node 1) et a reçu les identifiants du réseau Thread.
À présent, joignez le nœud 2 au réseau Thread (là encore, 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 vérifier qu'il a bien rejoint le réseau. En 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 à l'aide de la commande Ctrl+D ou exit, puis revenez à la console bash du conteneur. Depuis cette console, pinguez le nœud 1 en utilisant son EID avec la commande ping6. Si l'instance RCP ot-daemon est correctement jointe au réseau Thread et qu'elle communique avec lui, le ping aboutit:
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 Docker
Si vous avez quitté le conteneur Docker
bash invites, vous devrez peut-être vérifier s'il est en cours d'exécution et le redémarrer / le saisir à nouveau si nécessaire. Tous les conteneurs Docker que vous avez créés et pour lesquels vous n'avez pas utilisé l'option --rm doivent 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 vous ne voyez pas le conteneur codelab_otsim_ctnr dans le résultat de l'une 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/environment bash
N'utilisez l'option --rm que si vous souhaitez que le conteneur soit supprimé à sa fermeture.
Si le conteneur est arrêté (répertorié 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 (répertorié dans docker ps), reconnectez-vous au conteneur dans chaque terminal:
$ docker exec -it codelab_otsim_ctnr bash
"Opération non autorisée" erreurs
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. Cet atelier de programmation ne permet pas d'exécuter Docker en mode sans racine.
7. Félicitations !
Vous avez réussi à simuler votre premier réseau Thread à l'aide d'OpenThread. Parfait !
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 un daemon OpenThread
Pour en savoir plus sur Thread et OpenThread, consultez ces références:
- Thread Primer sur openthread.io
- Spécification du thread
- Dépôt GitHub OpenThread
- Référence de la CLI OpenThread
- Prise en charge supplémentaire de Docker OpenThread
Ou, essayez d'utiliser le routeur de bordure OpenThread dans un conteneur Docker !