1. Introduction
Heureux est un outil créé par Nest Labs pour l' orchestration légère de topologies de réseau simulé. Happy est utile pour le développement et le test des réseaux domestiques IoT.
Avec Happy, vous pouvez :
- Testez les protocoles réseau et autres programmes d'exécution distribués sur une seule machine de développement Linux sans utiliser le matériel de l'appareil IoT
- Effectuer des tests fonctionnels automatisés sur un réseau
- Exécutez plusieurs réseaux parallèles simultanés sur le même système pour améliorer le débit de test
Dans ce Codelab, vous apprendrez comment démarrer avec Happy, ainsi que les bases de Weave pour les appareils IdO. La mise en œuvre Weave que vous allez utiliser est OpenWeave , une version open source publié par Nest.
Ce que vous apprendrez
- Comment créer Happy et OpenWeave
- Comment créer manuellement un réseau IoT simulé
- Comment gérer les topologies personnalisées
- Comment connecter un réseau Happy simulé à Internet
- Les bases du tissage
Ce dont vous aurez besoin
- Une machine Linux, physique ou virtuelle
- Client Git ou cli
- Python 2.7
- Une compréhension de base des concepts de mise en réseau et de routage
2. Commencez
Installer la chaîne d'outils et les dépendances
Pour créer Happy et Weave, assurez-vous d'avoir une chaîne d'outils prise en charge et toutes les dépendances installées.
$ sudo apt-get update
$ sudo apt-get install -y autotools-dev build-essential git lcov \
libdbus-1-dev libglib2.0-dev libssl-dev \
libudev-dev make python2.7 software-properties-common \
python-setuptools bridge-utils python-lockfile \
python-psutil
$ sudo apt-get install -y --force-yes gcc-arm-none-eabi
$ sudo apt-get update -qq
Obtenez le code source
Clonez les dépôts Happy et OpenWeave Git à partir de la ligne de commande :
$ cd ~ $ git clone https://github.com/openweave/happy.git $ git clone https://github.com/openweave/openweave-core.git
Installer Happy
Depuis le répertoire racine de Happy, installez Happy :
$ cd ~/happy $ make
Vérifier Bonne installation
Les commandes Happy devraient maintenant être accessibles depuis la ligne de commande :
$ happy-state State Name: happy NETWORKS Name Type State Prefixes NODES Name Interface Type IPs
Installer OpenWeave
Depuis le répertoire racine d'OpenWeave, installez OpenWeave :
$ cd ~/openweave-core $ make -f Makefile-Standalone
Configurer Happy avec OpenWeave
Pour utiliser OpenWeave avec Happy, vous devez indiquer à Happy où trouver l'installation de Weave. Mettre à jour la configuration heureux avec le chemin d'accès /src/test-apps dans votre build OpenWeave:
$ happy-configuration weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Confirmez la configuration :
$ happy-configuration
User Happy Configuration
weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Vérifier l'installation d'OpenWeave
Les commandes Weave nécessaires dans ce Codelab sont accessibles à partir de la ligne de commande :
$ weave-fabric-add -h
weave-fabric-add creates a weave fabric.
weave-fabric-add [-h --help] [-q --quiet] [-i --id <FABRIC_ID>]
Example:
$ weave-fabric-add 123456
Creates a Weave Fabric with id 123456
return:
0 success
1 fail
Si vous obtenez l'erreur weave-fabric-add: command not found , mettez à jour votre PATH variable d'environnement avec le chemin utilisé pour les fichiers binaires Happy:
$ export PATH=$PATH:~/openweave-core/src/test-apps/happy/bin
3. Votre première topologie
Créons la topologie à trois nœuds suivante avec Happy.
Cette topologie est un exemple de réseau domestique (HAN) simple. Dans ce HAN, deux nœuds sont connectés ensemble dans un réseau Thread, et l'un de ces nœuds se connecte à un troisième via Wi-Fi. Ce nœud peut également être connecté à un routeur sans fil dans la maison pour fournir une connectivité Internet à l'ensemble du HAN. Plus à ce sujet plus tard.
Tout d'abord, créez les trois nœuds :
$ happy-node-add 01ThreadNode $ happy-node-add 02BorderRouter $ happy-node-add 03WiFiNode
Assurons-nous qu'ils existent :
$ happy-node-list 01ThreadNode 02BorderRouter 03WiFiNode
Créons maintenant quelques réseaux :
$ happy-network-add ThreadNetwork thread $ happy-network-add WiFiNetwork wifi
Vérifiez que les réseaux existent :
$ happy-network-list ThreadNetwork WiFiNetwork
Vérifiez l'état Heureux :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP
WiFiNetwork wifi UP
NODES Name Interface Type IPs
01ThreadNode
02BorderRouter
03WiFiNode
Il ne suffit pas de créer un réseau, nous devons ajouter des nœuds aux réseaux. En suivant notre schéma de topologie, ajoutez chaque nœud au(x) réseau(x) approprié(s) :
$ happy-node-join 01ThreadNode ThreadNetwork $ happy-node-join 02BorderRouter ThreadNetwork $ happy-node-join 02BorderRouter WiFiNetwork $ happy-node-join 03WiFiNode WiFiNetwork
Notez que 02BorderRouter a été ajouté à la fois ThreadNetwork et WiFiNetwork . C'est parce qu'en tant que routeur frontière au sein de notre HAN, ce nœud connecte les deux réseaux individuels ensemble.
Vérifiez l'état Heureux. Les interfaces de chaque nœud sont actives :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP
WiFiNetwork wifi UP
NODES Name Interface Type IPs
01ThreadNode wpan0 thread
02BorderRouter wpan0 thread
wlan0 wifi
03WiFiNode wlan0 wifi
Notre topologie ressemble maintenant à ceci :
La dernière étape de la mise en place de notre réseau Happy consiste à attribuer des adresses IP à chaque interface sur chaque nœud. Spécifiez le préfixe IP d'un réseau et Happy vous attribue automatiquement des adresses IP.
Étant donné que le protocole Thread utilise IPv6, ajoutez un préfixe IPv6 au réseau Thread :
$ happy-network-address ThreadNetwork 2001:db8:1:2::
Vérifiez l'état Heureux. Les interfaces Thread sur chaque nœud Thread ont des adresses IP :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP 2001:0db8:0001:0002/64
WiFiNetwork wifi UP
NODES Name Interface Type IPs
01ThreadNode wpan0 thread 2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
02BorderRouter wpan0 thread 2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64
wlan0 wifi
03WiFiNode wlan0 wifi
Pour le réseau WiFi, ajoutez les préfixes IPv4 et IPv6 :
$ happy-network-address WiFiNetwork 2001:db8:a:b:: $ happy-network-address WiFiNetwork 10.0.1.0
Vérifiez à nouveau l'état Heureux. Toutes les interfaces ont des adresses IP attribuées, avec deux pour chaque interface Wi-Fi :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP 2001:0db8:0001:0002/64
WiFiNetwork wifi UP 2001:0db8:000a:000b/64
10.0.1/24
NODES Name Interface Type IPs
01ThreadNode wpan0 thread 2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
02BorderRouter wpan0 thread 2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64
wlan0 wifi 10.0.1.2/24
2001:0db8:000a:000b:426c:38ff:fe90:01e6/64
03WiFiNode wlan0 wifi 2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
10.0.1.3/24
Voici notre topologie mise à jour :
4. Testez la connectivité
Maintenant que notre réseau est heureux et en cours d' exécution, nous allons tester sa connectivité par les autres nœuds pinger de 01ThreadNode :
$ happy-ping 01ThreadNode 02BorderRouter
[Ping] ping from 01ThreadNode to 02BorderRouter on address
10.0.1.2 -> 100% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
2001:0db8:0001:0002:a651:3eff:fe92:6dbc -> 0% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
2001:0db8:000a:000b:426c:38ff:fe90:01e6 -> 100% packet loss
$ happy-ping 01ThreadNode 03WiFiNode
[Ping] ping from 01ThreadNode to 03WiFiNode on address
2001:0db8:000a:000b:9aae:2bff:fe71:62fa -> 100% packet loss
[Ping] ping from 01ThreadNode to 03WiFiNode on address
10.0.1.3 -> 100% packet loss
Les happy-ping commande tente de ping chaque adresse IP pour chaque interface sur le nœud cible. Nous pouvons ignorer les adresses IPv4 car Thread n'utilise que IPv6.
Notez que seul ping IPv6 a réussi: celui sur 02BorderRouter de wpan0 interface, qui est la seule adresse 01ThreadNode peut directement atteindre:
Les autres adresses IPv6 ont échoué parce que le transfert n'a pas été activé entre wpan0 et wlan0 sur 02BorderRouter . Ainsi, 01ThreadNode n'a aucune idée 03WiFiNode existe, ou comment l'atteindre. Happy a mis en place le réseau simulé, mais n'a pas activé tous les routages et transferts entre les nœuds.
Ajouter des itinéraires
Pour acheminer le trafic IPv6 à travers le HAN, ajoutez les routes appropriées à chaque nœud de chaque réseau, dans les deux sens (afin que le ping sache comment revenir au nœud source).
Pour chaque nœud, vous aurez besoin de savoir :
- la plus proche passerelle dans ce cas réseau,
02BorderRouterpour les deux - le réseau cible—où aller après la passerelle
Pour notre réseau à trois nœuds, cela nous donne ce qui suit :
du réseau source | au réseau cible | via la passerelle |
| | |
| | |
Cela peut être fait individuellement pour chaque noeud avec happy-node-route , mais il est plus facile de le faire pour tous les noeuds dans chaque réseau avec happy-network-route .
$ happy-network-route -a -i ThreadNetwork -t default -v 02BorderRouter -p 2001:db8:1:2::/64 $ happy-network-route -a -i WiFiNetwork -t default -v 02BorderRouter -p 2001:db8:a:b::/64
Pour une explication des drapeaux de ligne de commande, utilisez happy-network-route -h .
Le happy-network-route commande permet également d' activer le transfert IPv4 et IPv6 pour chaque nœud, au besoin. Cela permet au trafic d'être acheminé d'une interface à une autre au sein d'un nœud.
Réessayez maintenant le ping :
$ happy-ping 01ThreadNode 02BorderRouter
[Ping] ping from 01ThreadNode to 02BorderRouter on address
10.0.1.2 -> 100% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
2001:0db8:0001:0002:a651:3eff:fe92:6dbc -> 0% packet loss
[Ping] ping from 01ThreadNode to 02BorderRouter on address
2001:0db8:000a:000b:426c:38ff:fe90:01e6 -> 0% packet loss
Les deux pings IPv6 fonctionnent ! Avec forwarding, il sait comment atteindre la wlan0 interface. Le ping IPv4 échoue toujours, car nous n'avons configuré que les routes et le transfert IPv6 (également parce que Thread ne s'exécute pas sur IPv4).
Puisque nous avons ajouté des routes réseau des deux côtés, ping sur les réseaux :
$ happy-ping 01ThreadNode 03WiFiNode
[Ping] ping from 01ThreadNode to 03WiFiNode on address
2001:0db8:000a:000b:9aae:2bff:fe71:62fa -> 0% packet loss
[Ping] ping from 01ThreadNode to 03WiFiNode on address
10.0.1.3 -> 100% packet loss
Le ping IPv6 fonctionne comme prévu. Vous disposez maintenant d'un HAN IPv6 simulé entièrement fonctionnel.
Pour permettre un moyen plus sûr et fiable de tout connecter ensemble, ajoutons Weave au-dessus du HAN.
5. Ajouter le tissage
Weave est une couche d'application réseau qui fournit l'épine dorsale des communications sécurisées et fiables pour les produits Nest. Nous pouvons ajouter la fonctionnalité Weave avec OpenWeave, la version open source de Weave.
Une implémentation de Weave est appelée "tissu". Un tissu Weave est un réseau qui comprend tous les nœuds HAN, le service Nest et tous les appareils mobiles participant au HAN. Il se trouve au-dessus du HAN et permet un routage plus facile entre les différentes technologies de liaison réseau sous-jacentes (par exemple, Thread ou Wi-Fi).
Créer le tissu Weave pour votre HAN, en utilisant fab1 comme ID tissu, puis configurer tous les nœuds pour Weave:
$ weave-fabric-add fab1 $ weave-node-configure
Maintenant que Weave est configuré, vérifiez l'état Happy :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP 2001:0db8:0001:0002/64
WiFiNetwork wifi UP 2001:0db8:000a:000b/64
10.0.1/24
NODES Name Interface Type IPs
01ThreadNode wpan0 thread 2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64
02BorderRouter wpan0 thread fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64
wlan0 wifi fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
10.0.1.2/24
2001:0db8:000a:000b:426c:38ff:fe90:01e6/64
03WiFiNode wlan0 wifi 2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
10.0.1.3/24
fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64
Chaque noeud a été ajouté à l'étoffe tissée, et chaque interface a une nouvelle adresse IPv6 à partir de fd00 . Pour obtenir plus d' informations sur le tissu Weave, utilisez l' weave-state commande:
$ weave-state
State Name: weave
NODES Name Weave Node Id Pairing Code
01ThreadNode 69ca9502eb6911e7 8ZJB5Q
02BorderRouter 686af236eb6911e7 B5YV3P
03WiFiNode 69826e60eb6911e7 L3VT3A
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Voici notre topologie mise à jour, avec les valeurs Weave en bleu :
Tisser du tissu
Il y a beaucoup de nouvelles informations dans les états Weave et Happy. Le début Let avec le tissu de weave-state :
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Utilisations Weave un préfixe IPv6 de fd00::/48 pour chaque nœud. Les adresses de ce bloc sont appelées adresses locales uniques et sont conçues pour être utilisées dans des réseaux privés tels qu'un HAN. La combinaison de cela avec l'ID de tissu génère le préfixe global de tissage illustré ci-dessus.
Tisser des nœuds
Chaque nœud du tissu Weave se voit attribuer un ID de nœud unique, ainsi qu'un code d'appariement :
NODES Name Weave Node Id Pairing Code
01ThreadNode 69ca9502eb6911e7 8ZJB5Q
02BorderRouter 686af236eb6911e7 B5YV3P
03WiFiNode 69826e60eb6911e7 L3VT3A
L'ID de nœud identifie globalement un nœud dans la structure Weave. Le code d'appariement est utilisé comme « identifiant de connexion » pendant le processus d'appariement et est généralement imprimé à côté du code QR d'un produit.
Par exemple, si vous regardez le code QR sur un Nest Protect ou une Nest Cam, vous remarquerez une chaîne de 6 caractères, souvent appelée clé d'entrée. C'est le code d'appariement de tissage.
Weave utilise une combinaison du préfixe global, de l'ID de matrice et de l'ID de nœud pour créer des adresses IPv6 spécifiques à Weave pour chaque nœud et interface de la matrice.
Tisser des adresses
Notez qu'il existe quatre nouvelles adresses IPv6 dans la topologie Heureux, tout en commençant par notre Weave mondial Prefix de fd00:0000:fab1::/48 .
NODES Name Interface Type IPs
01ThreadNode wpan0 thread 2001:0db8:0001:0002:3e36:13ff:fe33:732e/64
fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64
02BorderRouter wpan0 thread fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64
wlan0 wifi fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
10.0.1.2/24
2001:0db8:000a:000b:426c:38ff:fe90:01e6/64
03WiFiNode wlan0 wifi 2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
10.0.1.3/24
fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64
Les protocoles Weave utilisent ces adresses pour communiquer à travers la structure Weave, plutôt que les adresses IPv6 standard attribuées à chaque nœud.
Passerelle de réseau Weave
Les nœuds Weave sur un réseau Thread doivent savoir où sortir de ce réseau. Une passerelle réseau Weave, généralement sur un Thread Border Router, fournit cette fonctionnalité.
Dans notre exemple de topologie, désignons le nœud BorderRouter comme passerelle de réseau Weave :
$ weave-network-gateway ThreadNetwork 02BorderRouter
Cette commande ajoute un itinéraire à partir de tous les noeuds de fil vers le sous - réseau de tissu d' armure ( fd:0:fab1::/48 ) par l'intermédiaire du BorderRouter interface de fil de noeud ( wpan0 ), qui permet à chaque noeud de fil pour accéder à un noeud quelconque d' armure au - delà du réseau de fil. Ceci est analogue à l' happy-network-route commande , nous avons utilisé plus tôt, mais spécifique aux routes de tissu Weave.
6. Maintenance de la topologie
Ce qui rend Happy si puissant, c'est la facilité avec laquelle il gère toute la configuration et le démontage d'une topologie simulée.
Enregistrez votre topologie Happy pour une utilisation ultérieure :
$ happy-state -s codelab.json
Cela place un fichier JSON avec la topologie complète dans votre racine ~/ dossier. Le fichier JSON est une copie de votre état actuel Heureux, qui se trouve à ~/.happy_state.json .
Une fois enregistrée, supprimez la topologie actuelle :
$ happy-state-delete
Cela supprime tous les espaces de noms et configurations réseau voisins dans les ~/.happy-state.json fichier. Vérifiez happy-state et weave-state pour confirmer une configuration vide:
$ happy-state State Name: happy NETWORKS Name Type State Prefixes NODES Name Interface Type IPs $ weave-state State Name: weave NODES Name Weave Node Id Pairing Code FABRIC Fabric Id Global Prefix
Pour recharger une configuration enregistrée, utilisez l'une des deux commandes suivantes :
-
happy-state-load- ne supporte pas les plug - in Weave - le
weave-state-loadl'weave-state-load- supports de plug - in d' armure
Donc , si votre topologie comprend Weave, utilisez toujours le weave-state-load l' weave-state-load commande afin que le tissu Weave et la configuration associée est appliquée.
Rechargez la topologie Happy enregistrée :
$ weave-state-load codelab.json
Vérifiez tous les états pour confirmer un chargement réussi :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP 2001:0db8:0001:0002/64
WiFiNetwork wifi UP 2001:0db8:000a:000b/64
10.0.1/24
NODES Name Interface Type IPs
01ThreadNode wpan0 thread 2001:0db8:0001:0002:eef6:a0ff:feca:6697/64
fd00:0000:fab1:0006:6bca:9502:eb69:11e7/64
02BorderRouter wpan0 thread fd00:0000:fab1:0006:6a6a:f236:eb69:11e7/64
2001:0db8:0001:0002:5e53:bbff:fe05:484b/64
wlan0 wifi 2001:0db8:000a:000b:2e61:fdff:fed9:4fbc/64
fd00:0000:fab1:0001:6a6a:f236:eb69:11e7/64
10.0.1.2/24
03WiFiNode wlan0 wifi fd00:0000:fab1:0001:6b82:6e60:eb69:11e7/64
10.0.1.3/24
2001:0db8:000a:000b:5e8e:c9ff:fed2:bdd1/64
$ weave-state
State Name: weave
NODES Name Weave Node Id Pairing Code
01ThreadNode 69ca9502eb6911e7 8ZJB5Q
02BorderRouter 686af236eb6911e7 B5YV3P
03WiFiNode 69826e60eb6911e7 L3VT3A
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Un certain nombre de topologies prédéfinies ont été fournies dans le référentiel Happy, à la fois au format shell-script et JSON. Vous les trouverez à ~/happy/topologies .
OpenWeave est également fourni avec une sélection de topologies Happy prédéfinies à des fins de test. Vous les trouverez à ~/openweave-core/src/test-apps/happy/topologies/standalone .
7. Comment ça marche
Happy utilise des espaces de noms de réseau Linux pour simuler des topologies complexes. En règle générale, une configuration réseau s'applique à l'ensemble du système d'exploitation Linux. Les espaces de noms réseau vous permettent de partitionner les configurations réseau de sorte que chaque espace de noms possède son propre ensemble d'interfaces et de tables de routage.
Chaque nœud et réseau dans Happy est un espace de noms de réseau, tandis que les liens entre eux sont des interfaces réseau.
Par exemple, en utilisant notre topologie :
Voyons quels espaces de noms Happy a créés pour cela :
$ ip netns list happy004 happy003 happy002 happy001 happy000
Si vous cochez la netns section du fichier JSON d'état heureux, vous pouvez voir ce que les nœuds et les réseaux chacun correspond à l' espace de noms:
$ happy-state -j | grep "netns" -A 5
"netns": {
"01ThreadNode": "000",
"02BorderRouter": "001",
"03WiFiNode": "002",
"ThreadNetwork": "003",
"WiFiNetwork": "004",
Journaux d'exécution
Les commandes envoyées aux nœuds sont des commandes de terminal de base exécutées à partir de l'espace de noms de chaque nœud. Un moyen simple de le voir est d'activer les journaux d'exécution Happy.
Ouvrez une deuxième fenêtre de terminal et activez les journaux, ils s'exécuteront en continu sur cette fenêtre :
$ happy-state -l
Revenez à la première fenêtre et lancez un ping Happy :
$ happy-ping 01ThreadNode 02BorderRouter
Vérifiez les entrées de journal les plus récentes dans la deuxième fenêtre du terminal. Vous devriez voir une ligne comme celle-ci dans les journaux :
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ping6 -c 1 2001:0db8:0001:0002:5e53:bbff:fe05:484b
Le happy-ping commande est rien de plus que la Bonne course ping6 commande dans le happy000 espace de noms ( 01ThreadNode ).
Entrez un nœud
Utiliser happy-shell pour exécuter des commandes non Happy comme si connecté à un des noeuds (espaces de noms de réseau):
$ happy-shell 01ThreadNode root@01ThreadNode:#
Les appareils simulés sont exécutés dans chaque espace de noms et n'ont accès qu'à la configuration réseau spécifiée via Happy.
Vérifiez la configuration de l'interface pour le nœud. Ce sera différent de votre configuration à l'échelle du système d'exploitation et devrait refléter ce qui est répertorié dans l'état Heureux :
root@01ThreadNode:# ifconfig
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:1 errors:0 dropped:0 overruns:0 frame:0
TX packets:1 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1
RX bytes:152 (152.0 B) TX bytes:152 (152.0 B)
wpan0 Link encap:Ethernet HWaddr ec:f6:a0:ca:66:97
inet6 addr: fd00:0:fab1:6:6bca:9502:eb69:11e7/64 Scope:Global
inet6 addr: 2001:db8:1:2:eef6:a0ff:feca:6697/64 Scope:Global
inet6 addr: fe80::eef6:a0ff:feca:6697/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:32 errors:0 dropped:0 overruns:0 frame:0
TX packets:26 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:2832 (2.8 KB) TX bytes:2348 (2.3 KB)
Utilisez la exit pour quitter l'espace de noms du nœud:
root@01ThreadNode:# exit
8. Se connecter à un service
En comprenant comment Happy utilise les espaces de noms de réseau Linux, vous pouvez maintenant réaliser qu'il est possible de connecter un réseau Happy simulé à Internet et d'accéder à des adresses publiques à partir de nœuds simulés. Ceci est utile pour connecter vos appareils simulés à un service réel (comme le service Nest sur Weave).
Le service de Weave est une infrastructure basée sur le cloud qui connecte les nœuds HAN à un modèle de données, fournit un accès à distance et met en œuvre des contrôleurs intelligents pour créer un écosystème complet.
Le service peut être représenté de deux manières principales avec Happy :
- En tant que service simulé dans son propre espace de noms réseau (Happy node)
- En tant que véritable service cloud sur Internet
Topologies prédéfinies ont été fournies dans ~/happy/topologies comme un exemple de chaque scénario de service.
Service simulé sur un nœud Happy
Supprimez toutes les topologies Happy existantes :
$ happy-state-delete
Confirmer un état vide avec les happy-state et weave-state l' weave-state commandes.
Chargez une topologie prédéfinie avec un point d'accès (AP) et des nœuds de service :
$ weave-state-load ~/happy/topologies/thread_wifi_ap_service.json
Vérifiez les états Happy et Weave pour confirmer la topologie. Dans cette topologie, onhub est le point d' accès, tout en cloud est le service simulé. Remarque Les deux sont reliés à un Internet réseau de type wan :
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
HomeThread thread UP 2001:0db8:0111:0001/64
HomeWiFi wifi UP 2001:0db8:0222:0002/64
10.0.1/24
Internet wan UP 192.168.100/24
NODES Name Interface Type IPs
BorderRouter wpan0 thread 2001:0db8:0111:0001:f624:13ff:fe4a:6def/64
fd00:0000:fab1:0006:1ab4:3000:0000:0005/64
wlan0 wifi 10.0.1.2/24
fd00:0000:fab1:0001:1ab4:3000:0000:0005/64
2001:0db8:0222:0002:9e31:97ff:fe73:29f0/64
ThreadNode wpan0 thread 2001:0db8:0111:0001:c237:fbff:fecc:b082/64
fd00:0000:fab1:0006:1ab4:3000:0000:0009/64
cloud eth0 wan 192.168.100.3/24
onhub wlan0 wifi 10.0.1.3/24
2001:0db8:0222:0002:3266:20ff:fe98:6ee2/64
eth0 wan 192.168.100.2/24
$ weave-state
State Name: weave
NODES Name Weave Node Id Pairing Code
BorderRouter 18B4300000000005 AAA123
ThreadNode 18B4300000000009 AAA123
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Tunnel de tissage
Un tunnel Weave connecte le tissu Weave à un service. Il s'agit d'une route sécurisée qui transfère les messages UDP IPv6 entre le HAN et le service. Dans cette topologie, le BorderRouter noeud est la passerelle de réseau d' armure, qui fonctionne comme le point de terminaison de tunnel sur le HAN.
Créez le tunnel de tissage :
$ weave-tunnel-start BorderRouter cloud
Revérifiez l'état Heureux. Vous devriez voir une nouvelle interface de tunnel avec une adresse IPv6 Weave sur le cloud noeud:
NODES Name Interface Type IPs
cloud service-tun0 tun fd00:0000:fab1:0005:1ab4:3002:0000:0011/64
eth0 wan 192.168.100.3/24
Vous pouvez désormais effectuer une requête ping entre les nœuds de la structure Weave et le préfixe global Weave du service :
$ happy-ping ThreadNode cloud
[Ping] ping from ThreadNode to cloud on address
fd00:0000:fab1:0005:1ab4:3002:0000:0011 -> 0% packet loss
Un vrai service cloud sur Internet
Supprimez toutes les topologies Happy existantes :
$ happy-state-delete
Confirmer un état vide avec les happy-state et weave-state l' weave-state commandes.
Chargez une topologie prédéfinie avec un nœud de point d'accès (AP) :
$ weave-state-load ~/happy/topologies/thread_wifi_ap_internet.json
Dans cette topologie, onhub est le point d' accès. Vérifiez l'état Heureux. Il est similaire à la topologie précédente, sans l' Internet réseau et cloud noeud:
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
HomeThread thread UP 2001:0db8:0111:0001/64
HomeWiFi wifi UP 2001:0db8:0222:0002/64
10.0.1/24
NODES Name Interface Type IPs
BorderRouter wpan0 thread 2001:0db8:0111:0001:ca3f:71ff:fe53:1559/64
fd00:0000:fab1:0006:1ab4:3000:0000:0006/64
wlan0 wifi 2001:0db8:0222:0002:32e7:dfff:fee2:107a/64
fd00:0000:fab1:0001:1ab4:3000:0000:0006/64
10.0.1.2/24
ThreadNode wpan0 thread 2001:0db8:0111:0001:c2fb:97ff:fe04:64bd/64
fd00:0000:fab1:0006:1ab4:3000:0000:000a/64
onhub wlan0 wifi 10.0.1.3/24
2001:0db8:0222:0002:3a3c:8dff:fe38:999b/64
$ weave-state
State Name: weave
NODES Name Weave Node Id Pairing Code
BorderRouter 18B4300000000006 AAA123
ThreadNode 18B430000000000A AAA123
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Étant donné que chaque nœud Happy est un espace de noms réseau, ils sont partitionnés à partir de l'Internet public par défaut. Testez cela en entrant un nœud Happy et en pingant une adresse Internet publique. Nous allons utiliser 8.8.8.8 , l' une des adresses IPv4 de google.com.
$ happy-shell onhub root@onhub:# ping -c2 8.8.8.8 connect: Network is unreachable
Pour connecter le onhub nœud à l'Internet, il doit être comblé à cette interface sur la configuration de niveau système d' exploitation Linux.
Quittez le nœud :
root@onhub:# exit
Déterminez l'interface pour votre connexion Internet avec l' route commande:
$ route Kernel IP routing table Destination Gateway Genmask Flags Metric Ref Use Iface default 192.168.1.0 0.0.0.0 UG 0 0 0 em1
Trouvez la default itinéraire. Il s'agit de la connexion Internet de votre machine Linux. La Iface colonne indique que l' interface est utilisée pour que la connectivité. Dans l'exemple ci - dessus, il est em1 .
Utilisez happy-internet pour mettre en place le pont, en utilisant l'interface pour votre itinéraire par défaut. Pour le --isp drapeau, utilisez le nom de l' interface sans numéro de fuite. Dans cet exemple, il est em . Si votre interface par défaut est eth1 , le --isp drapeau serait eth .
$ happy-internet --node onhub --interface em1 --isp em --seed 249
Il n'y aura pas de changement visible dans l' happy-state sortie, mais le onhub nœud doit disposer d'une connectivité Internet. Revenons dans le nœud et vérifions :
$ happy-shell onhub root@onhub:# ping -c2 8.8.8.8 PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data. 64 bytes from 8.8.8.8: icmp_seq=1 ttl=56 time=1.81 ms 64 bytes from 8.8.8.8: icmp_seq=2 ttl=56 time=1.81 ms --- 8.8.8.8 ping statistics --- 2 packets transmitted, 2 received, 0% packet loss, time 1001ms rtt min/avg/max/mdev = 1.814/1.816/1.819/0.042 ms
Succès!
DNS
Les nœuds heureux n'ont pas de capacités DNS intégrées. Si vous essayez d'envoyer un ping à google.com, cela échoue :
root@onhub:# ping -c2 google.com ping: unknown host google.com
Heureusement, Happy prend en charge DNS. Quittez le nœud et recherchez les serveurs DNS de votre machine Linux. Assurez-vous d'utiliser l'interface par défaut appropriée :
root@onhub:# exit $ nmcli dev list iface em1 | grep domain_name_servers DHCP4.OPTION[13]: domain_name_servers = 172.16.255.1 172.16.255.153 172.16.255.53
Utilisez ces adresses DNS avec happy-dns :
$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53
Maintenant , essayez de pinger google.com dans le onhub noeud:
$ happy-shell onhub root@onhub:# ping -c2 google.com PING google.com (64.233.191.113) 56(84) bytes of data. 64 bytes from ja-in-f113.1e100.net (64.233.191.113): icmp_seq=1 ttl=46 time=36.9 ms 64 bytes from ja-in-f113.1e100.net (64.233.191.113): icmp_seq=2 ttl=46 time=37.0 ms --- google.com ping statistics --- 2 packets transmitted, 2 received, 0% packet loss, time 1001ms rtt min/avg/max/mdev = 36.978/36.995/37.013/0.193 ms
Quittez le onhub nœud lorsque vous avez terminé:
root@onhub:# exit
Tunnel de tissage
Comme le service simulé, un tunnel Weave doit être mis en place entre le HAN simulé dans Happy et le service. Avec un vrai service cloud, utilisez l'adresse IP ou l'URL du service dans la configuration du tunnel. Par exemple:
$ weave-tunnel-start BorderRouter mycloud.service.com
9. Nettoyer
Il est important de toujours nettoyer les topologies Happy lorsque vous en avez terminé, pour éviter les problèmes avec votre configuration réseau Linux.
Si vous avez activé le soutien DNS dans votre topologie, retirez - le en exécutant de nouveau cette commande avec le -d indicateur (suppression) en premier. Cela doit être exécuté avant la suppression des nœuds Happy, pour garantir que la configuration du réseau est correctement mise à jour.
$ happy-dns -d 172.16.255.1 172.16.255.153 172.16.255.53
Ensuite, supprimez l'état Happy :
$ happy-state-delete
Parfois, certains fichiers d'état peuvent rester après une suppression d'état. Si vous rencontrez des problèmes et heureux ne fonctionne pas comme prévu, supprimez l'état avec happy-state-delete de happy-state-delete , puis utilisez les commandes suivantes pour forcer tout nettoyage restant à courir jusqu'à:
$ ip netns | xargs -I {} sudo ip netns delete {}
$ rm -rf ~/.*state.json
$ rm -rf ~/.*state.json.lock
Votre machine devrait revenir à sa configuration réseau normale.
10. Félicitations !
Vous savez maintenant :
- Comment utiliser Happy pour simuler vos propres réseaux domestiques IoT
- Comment connecter des topologies Happy à Internet
- Les bases de Weave via OpenWeave, la version open source de Nest de Weave
Prochaines étapes
À partir de cet atelier de programmation, essayez les exercices suivants :
- Créez une topologie plus large avec plusieurs nœuds dans chaque réseau Thread et Wi-Fi, et établissez la connectivité entre tous les nœuds
- Créer un script bash pour charger la topologie via
happy-state-loadouweave-state-load - Explorez d' autres commandes Happy, comme
happy-tracerouteethappy-process-*
Lectures complémentaires
Vérifiez openweave.io pour une variété de références, y compris: