1. Introduzione
Felice è uno strumento creato dai laboratori Nest per l'orchestrazione leggera di topologie di rete simulati. Happy è utile per lo sviluppo e il test delle reti domestiche IoT.
Con Happy puoi:
- Testa i protocolli di rete e altri programmi di esecuzione distribuita su una singola macchina di sviluppo Linux senza utilizzare l'hardware del dispositivo IoT
- Eseguire test funzionali automatizzati su una rete
- Esegui più reti parallele simultanee sullo stesso sistema per migliorare il throughput dei test
In questo Codelab, imparerete come iniziare con Felice, così come le basi di tessuto per i dispositivi IoT. L'implementazione Weave che verrà utilizzato è OpenWeave , una versione open-source rilasciato da Nest.
Cosa imparerai
- Come costruire Happy e OpenWeave
- Come creare manualmente una rete IoT simulata
- Come gestire le topologie personalizzate
- Come collegare a Internet una rete Happy simulata
- Le basi di Weave
Di cosa avrai bisogno
- Una macchina Linux, fisica o virtuale
- Git client o cli
- Python 2.7
- Una conoscenza di base dei concetti di networking e routing
2. Inizia
Installa toolchain e dipendenze
Per creare Happy e Weave, assicurati di avere una toolchain supportata e tutte le dipendenze installate.
$ 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
Ottieni il codice sorgente
Clona i repository Git Happy e OpenWeave dalla riga di comando:
$ cd ~ $ git clone https://github.com/openweave/happy.git $ git clone https://github.com/openweave/openweave-core.git
Installa felice
Dalla directory principale di Happy, installa Happy:
$ cd ~/happy $ make
Verifica Buona installazione
I comandi Happy dovrebbero ora essere accessibili dalla riga di comando:
$ happy-state State Name: happy NETWORKS Name Type State Prefixes NODES Name Interface Type IPs
Installa OpenWeave
Dalla directory principale di OpenWeave, installa OpenWeave:
$ cd ~/openweave-core $ make -f Makefile-Standalone
Configura Happy con OpenWeave
Per utilizzare OpenWeave con Happy, devi far sapere a Happy dove trovare l'installazione di Weave. Aggiornare la configurazione Felice con il percorso /src/test-apps all'interno della vostra costruzione OpenWeave:
$ happy-configuration weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Conferma la configurazione:
$ happy-configuration
User Happy Configuration
weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Verifica l'installazione di OpenWeave
I comandi Weave necessari in questo Codelab sono accessibili dalla riga di comando:
$ 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
Se si ottiene l'errore weave-fabric-add: command not found , aggiornare il PATH variabile d'ambiente con il percorso usato per Happy binari:
$ export PATH=$PATH:~/openweave-core/src/test-apps/happy/bin
3. La tua prima topologia
Creiamo la seguente topologia a tre nodi con Happy.
Questa topologia è un esempio di una semplice Home Area Network (HAN). In questo HAN, due nodi sono collegati insieme in una rete Thread e uno di questi nodi si connette a un terzo tramite Wi-Fi. Questo nodo può anche essere collegato a un router wireless in casa per fornire connettività Internet per l'intero HAN. Maggiori informazioni su questo più tardi.
Innanzitutto, crea i tre nodi:
$ happy-node-add 01ThreadNode $ happy-node-add 02BorderRouter $ happy-node-add 03WiFiNode
Assicuriamoci che esistano:
$ happy-node-list 01ThreadNode 02BorderRouter 03WiFiNode
Ora creiamo alcune reti:
$ happy-network-add ThreadNetwork thread $ happy-network-add WiFiNetwork wifi
Verificare che le reti esistano:
$ happy-network-list ThreadNetwork WiFiNetwork
Controlla lo stato felice:
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP
WiFiNetwork wifi UP
NODES Name Interface Type IPs
01ThreadNode
02BorderRouter
03WiFiNode
Non è sufficiente creare una rete: dobbiamo aggiungere nodi alle reti. Seguendo il nostro diagramma della topologia, aggiungi ciascun nodo alle reti appropriate:
$ happy-node-join 01ThreadNode ThreadNetwork $ happy-node-join 02BorderRouter ThreadNetwork $ happy-node-join 02BorderRouter WiFiNetwork $ happy-node-join 03WiFiNode WiFiNetwork
Si noti che 02BorderRouter inserito sia ThreadNetwork e WiFiNetwork . Questo perché come Border Router all'interno del nostro HAN, questo nodo collega le due singole reti insieme.
Controlla lo stato felice. Le interfacce di ogni nodo sono attive:
$ 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
La nostra topologia ora ha questo aspetto:
L'ultimo passaggio nella creazione della nostra rete Happy è assegnare indirizzi IP a ciascuna interfaccia su ciascun nodo. Specifica il prefisso IP per una rete e Happy assegna automaticamente gli indirizzi IP per te.
Poiché il protocollo Thread utilizza IPv6, aggiungi un prefisso IPv6 alla rete Thread:
$ happy-network-address ThreadNetwork 2001:db8:1:2::
Controlla lo stato felice. Le interfacce Thread su ciascun nodo Thread hanno indirizzi 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
Per la rete WiFi, aggiungi entrambi i prefissi IPv4 e IPv6:
$ happy-network-address WiFiNetwork 2001:db8:a:b:: $ happy-network-address WiFiNetwork 10.0.1.0
Controlla ancora una volta lo stato Felice. Tutte le interfacce hanno indirizzi IP assegnati, con due per ogni interfaccia 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
Ecco la nostra topologia aggiornata:
4. Prova la connettività
Ora che la nostra rete Felice è attivo e funzionante, andiamo a testare la sua connettività eseguendo il ping gli altri nodi da 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
Gli happy-ping comando prova a eseguire il ping ogni indirizzo IP per ogni interfaccia sul nodo di destinazione. Possiamo ignorare gli indirizzi IPv4 perché Thread utilizza solo IPv6.
Nota che solo un ping IPv6 ha avuto successo: quello sul 02BorderRouter s' wpan0 interfaccia, che è l'unico indirizzo 01ThreadNode può raggiungere direttamente:
Gli altri indirizzi IPv6 non è riuscita perché l'inoltro non è stato attivato tra il wpan0 e wlan0 su 02BorderRouter . Così, 01ThreadNode ha idea 03WiFiNode esiste, o come raggiungerlo. Happy ha attivato la rete simulata, ma non ha abilitato tutto il routing e l'inoltro tra i nodi.
Aggiungi percorsi
Per instradare il traffico IPv6 attraverso l'HAN, aggiungi i percorsi appropriati a ciascun nodo in ciascuna rete, in entrambe le direzioni (in modo che il ping sappia come tornare al nodo di origine).
Per ogni nodo, dovrai sapere:
- la rete più vicino gateway in questo caso,
02BorderRouterper entrambi - la rete di destinazione: dove andare dopo il gateway?
Per la nostra rete a tre nodi, questo ci dà quanto segue:
dalla rete di origine | alla rete di destinazione | tramite Gateway |
| | |
| | |
Questo può essere fatto individualmente per ogni nodo con happy-node-route , ma è più facile farlo per tutti i nodi in ogni rete con 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
Per una spiegazione delle bandiere della riga di comando, utilizzare happy-network-route -h .
La happy-network-route di comando si accende anche l'inoltro IPv4 e IPv6 per ogni nodo, in base alle esigenze. Ciò consente al traffico di instradare da un'interfaccia all'altra all'interno di un nodo.
Ora riprova il 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
Entrambi i ping IPv6 funzionano! Con l'inoltro, sa come raggiungere l' wlan0 interfaccia. Il ping IPv4 fallisce ancora, perché abbiamo configurato solo le route e l'inoltro IPv6 (anche perché Thread non viene eseguito su IPv4).
Poiché abbiamo aggiunto route di rete su entrambi i lati, eseguiamo il ping tra le reti:
$ 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
Il ping IPv6 funziona come previsto. Ora hai un HAN IPv6 simulato completamente funzionante.
Per consentire un modo più sicuro e affidabile di collegare tutto insieme, aggiungiamo Weave sopra l'HAN.
5. Aggiungi trama
Weave è un livello di applicazione di rete che fornisce la dorsale di comunicazione sicura e affidabile per i prodotti Nest. Possiamo aggiungere la funzionalità Weave con OpenWeave, la versione open source di Weave.
Un'implementazione di Weave è chiamata "tessuto". Un tessuto Weave è una rete che comprende tutti i nodi HAN, il servizio Nest e tutti i dispositivi mobili che partecipano all'HAN. Si trova sopra l'HAN e consente un routing più semplice attraverso le diverse tecnologie di collegamento di rete sottostanti (ad esempio Thread o Wi-Fi).
Creare il tessuto tessuto per il vostro HAN, utilizzando fab1 come il Fabric ID, quindi configurare tutti i nodi per Weave:
$ weave-fabric-add fab1 $ weave-node-configure
Ora che Weave è configurato, controlla lo stato Felice:
$ 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
Ogni nodo è stato aggiunto al tessuto Weave, e ogni interfaccia ha un nuovo indirizzo IPv6 iniziano fd00 . Per avere maggiori informazioni sul tessuto Weave, utilizzare il weave-state comando:
$ 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
Ecco la nostra topologia aggiornata, con i valori di Weave in blu:
Tessuto tessere
Ci sono molte nuove informazioni negli stati Weave e Happy. La partenza di Let con il tessuto da weave-state :
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Usi tessere un prefisso IPv6 fd00::/48 per ciascun nodo. Gli indirizzi in questo blocco sono chiamati indirizzi locali univoci e sono designati per l'uso all'interno di reti private come un HAN. La combinazione di questo con l'ID tessuto genera il prefisso globale Weave mostrato sopra.
Intreccia i nodi
Ad ogni nodo nel tessuto Weave viene assegnato un ID nodo univoco, insieme a un codice di accoppiamento:
NODES Name Weave Node Id Pairing Code
01ThreadNode 69ca9502eb6911e7 8ZJB5Q
02BorderRouter 686af236eb6911e7 B5YV3P
03WiFiNode 69826e60eb6911e7 L3VT3A
L'ID nodo identifica globalmente un nodo nel tessuto Weave. Il codice di abbinamento viene utilizzato come "credenziale di joiner" durante il processo di abbinamento e in genere viene stampato insieme al codice QR di un prodotto.
Ad esempio, se guardi il codice QR su un Nest Protect o su una Nest Cam, noterai una stringa di 6 caratteri, spesso chiamata chiave di accesso. Questo è il codice di abbinamento di Weave.
Weave utilizza una combinazione di Global Prefix, Fabric ID e Node ID per creare indirizzi IPv6 specifici di Weave per ciascun nodo e interfaccia nel fabric.
Indirizzi di tessere
Nota che ci sono quattro nuovi indirizzi IPv6 nella topologia Felice, tutti a partire con il nostro tessuto globale Prefisso di 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
I protocolli Weave utilizzano questi indirizzi per comunicare attraverso il fabric Weave, anziché gli indirizzi IPv6 standard assegnati a ciascun nodo.
Intreccia il gateway di rete
I nodi Weave su una rete Thread devono sapere dove uscire da quella rete. Un gateway di rete Weave, in genere su un Thread Border Router, fornisce questa funzionalità.
Nella nostra topologia di esempio, designiamo il nodo BorderRouter come gateway di rete Weave:
$ weave-network-gateway ThreadNetwork 02BorderRouter
Questo comando aggiunge un percorso da tutti i nodi della discussione alla sottorete tessuto Weave ( fd:0:fab1::/48 ) tramite il BorderRouter interfaccia di filo di nodo ( wpan0 ), che consente a ogni nodo un messaggio privato a raggiungere qualsiasi nodo di tessuto al di là della rete di filo. Questo è analogo alla happy-network-route di comando che abbiamo usato in precedenza, ma specifiche per Weave percorsi di tessuto.
6. Manutenzione della topologia
Ciò che rende Happy così potente è la facilità con cui gestisce tutte le impostazioni e lo smontaggio di una topologia simulata.
Salva la tua topologia Happy per un uso successivo:
$ happy-state -s codelab.json
Questo un file JSON con la topologia completa nella vostra radice luoghi ~/ cartella. Il file JSON è una copia del tuo attuale stato di Felice, che si trova in ~/.happy_state.json .
Una volta salvato, elimina la topologia corrente:
$ happy-state-delete
Questo elimina tutti gli spazi dei nomi di rete e le configurazioni relative presenti nel ~/.happy-state.json file. Controllare happy-state e weave-state per confermare una configurazione vuota:
$ 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
Per ricaricare una configurazione salvata, utilizzare uno dei due comandi:
-
happy-state-load- non supporta plug-Weave -
weave-state-load- supporti di plugin Weave
Quindi, se la topologia include Weave, utilizzare sempre il weave-state-load comando in modo che viene applicato il tessuto Weave e di configurazione associati.
Ricarica la topologia Happy salvata:
$ weave-state-load codelab.json
Controllare tutti gli stati per confermare un caricamento riuscito:
$ 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
Nel repository Happy sono state fornite una serie di topologie predefinite, sia in formato shell-script che in formato JSON. Li trovate in ~/happy/topologies .
OpenWeave include anche alcune topologie Happy predefinite a scopo di test. Li trovate in ~/openweave-core/src/test-apps/happy/topologies/standalone .
7. Come funziona
Happy utilizza gli spazi dei nomi di rete Linux per simulare topologie complesse. In genere, una configurazione di rete si applica all'intero sistema operativo Linux. Gli spazi dei nomi di rete consentono di partizionare le configurazioni di rete in modo che ogni spazio dei nomi abbia il proprio set di interfacce e tabelle di routing.
Ogni nodo e rete in Happy è uno spazio dei nomi di rete, mentre i collegamenti tra di loro sono interfacce di rete.
Ad esempio, utilizzando la nostra topologia:
Vediamo quali spazi dei nomi Happy ha creato per questo:
$ ip netns list happy004 happy003 happy002 happy001 happy000
Se si seleziona la netns sezione del file JSON stato di Felice, si può vedere ciò che i nodi e le reti di ognuno corrisponde a namespace:
$ happy-state -j | grep "netns" -A 5
"netns": {
"01ThreadNode": "000",
"02BorderRouter": "001",
"03WiFiNode": "002",
"ThreadNetwork": "003",
"WiFiNetwork": "004",
Registri di runtime
I comandi impartiti ai nodi sono comandi terminali di base eseguiti all'interno dello spazio dei nomi di ciascun nodo. Un modo semplice per verificarlo consiste nell'abilitare i registri di runtime di Happy.
Apri una seconda finestra di terminale e attiva i log, verranno eseguiti continuamente su questa finestra:
$ happy-state -l
Torna alla prima finestra ed esegui un Happy ping:
$ happy-ping 01ThreadNode 02BorderRouter
Controllare le voci di registro più recenti nella seconda finestra del terminale. Dovresti vedere una riga come questa nei log:
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ping6 -c 1 2001:0db8:0001:0002:5e53:bbff:fe05:484b
La happy-ping comando è niente di più che felice che funziona il ping6 comando nella happy000 namespace ( 01ThreadNode ).
Inserisci un nodo
Utilizzare happy-shell per eseguire comandi non felice come se registrati in uno dei nodi (namespace di rete):
$ happy-shell 01ThreadNode root@01ThreadNode:#
I dispositivi simulati vengono eseguiti all'interno di ogni spazio dei nomi e hanno accesso solo alla configurazione di rete specificata tramite Happy.
Controllare la configurazione dell'interfaccia per il nodo. Questo sarà diverso dalla configurazione a livello di sistema operativo e dovrebbe riflettere ciò che è elencato nello stato Felice:
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)
Utilizzare exit di lasciare spazio dei nomi del nodo:
root@01ThreadNode:# exit
8. Connettiti a un servizio
Con una comprensione di come Happy utilizza gli spazi dei nomi di rete Linux, ora potresti renderti conto che è possibile connettere una rete Happy simulata a Internet e accedere agli indirizzi pubblici dall'interno dei nodi simulati. Questo è utile per connettere i tuoi dispositivi simulati a un servizio reale (come il servizio Nest su Weave).
Il servizio in Weave è un'infrastruttura basata su cloud che collega i nodi HAN in un modello di dati, fornisce l'accesso remoto e implementa controller intelligenti per creare un ecosistema completo.
Il servizio può essere rappresentato in due modi principali con Happy:
- Come un servizio simulato nel proprio spazio dei nomi di rete (nodo felice)
- Come un vero servizio cloud su Internet
Topologie predefiniti sono stati forniti in ~/happy/topologies come un esempio di ogni scenario di servizio.
Servizio simulato su un nodo Happy
Rimuovere eventuali topologie Happy esistenti:
$ happy-state-delete
Confermare uno stato vuoto con le happy-state e weave-state comandi.
Carica una topologia predefinita con punto di accesso (AP) e nodi di servizio:
$ weave-state-load ~/happy/topologies/thread_wifi_ap_service.json
Controllare gli stati Happy e Weave per confermare la topologia. In questa topologia, onhub è l'AP, mentre cloud è il servizio simulato. Nota entrambi sono collegati a Internet di rete di tipo 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 di tessitura
Un tunnel Weave collega il tessuto Weave a un servizio. Questo è un percorso sicuro che trasferisce i messaggi UDP IPv6 tra l'HAN e il servizio. In questa topologia, il BorderRouter nodo è il gateway di rete Weave, che funge da tunnel sulla HAN.
Crea il tunnel della trama:
$ weave-tunnel-start BorderRouter cloud
Ricontrolla lo stato felice. Si dovrebbe vedere una nuova interfaccia del tunnel con un indirizzo IPv6 Weave sulla cloud nodo:
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
Ora puoi eseguire correttamente il ping tra i nodi sul tessuto Weave e il prefisso globale Weave del servizio:
$ happy-ping ThreadNode cloud
[Ping] ping from ThreadNode to cloud on address
fd00:0000:fab1:0005:1ab4:3002:0000:0011 -> 0% packet loss
Servizio cloud reale su Internet
Rimuovere eventuali topologie Happy esistenti:
$ happy-state-delete
Confermare uno stato vuoto con le happy-state e weave-state comandi.
Carica una topologia predefinita con un nodo del punto di accesso (AP):
$ weave-state-load ~/happy/topologies/thread_wifi_ap_internet.json
In questa topologia, onhub è il AP. Controlla lo stato felice. E 'simile alla topologia precedente, senza l' Internet di rete e cloud nodo:
$ 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
Poiché ogni nodo Happy è uno spazio dei nomi di rete, per impostazione predefinita vengono partizionati dall'Internet pubblico. Provalo inserendo un nodo Happy ed eseguendo il ping di un indirizzo Internet pubblico. Useremo 8.8.8.8 , uno dei google.com indirizzi IPv4.
$ happy-shell onhub root@onhub:# ping -c2 8.8.8.8 connect: Network is unreachable
Per collegare il onhub nodo ad internet, deve essere colmato a tale interfaccia della configurazione a livello di sistema operativo Linux.
Uscire dal nodo:
root@onhub:# exit
Determinare l'interfaccia per la connessione a Internet con il route di comando:
$ 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
Trovare il default percorso. Questa è la connessione Internet per la tua macchina Linux. Iface colonna indica quale interfaccia viene utilizzata per tale connessione. Nell'esempio di cui sopra, è em1 .
Utilizzare happy-internet per impostare il ponte, utilizzando l'interfaccia per il percorso di default. Per la --isp bandierina, utilizzare il nome dell'interfaccia senza numeri finali. In questo esempio, è em . Se l'interfaccia di default è eth1 , il --isp bandiera sarebbe eth .
$ happy-internet --node onhub --interface em1 --isp em --seed 249
Non ci sarà alcun cambiamento visibile nella happy-state di uscita, ma onhub nodo dovrebbe avere connettività internet. Torniamo nel nodo e controlliamo:
$ 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
Successo!
DNS
I nodi felici non hanno funzionalità DNS integrate. Se provi a eseguire il ping su google.com, fallisce:
root@onhub:# ping -c2 google.com ping: unknown host google.com
Fortunatamente, Happy fornisce supporto per DNS. Esci dal nodo e trova i server DNS per la tua macchina Linux. Assicurati di utilizzare l'interfaccia predefinita appropriata:
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
Utilizzare questi indirizzi DNS con happy-dns :
$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53
Ora provate a pingare google.com dall'interno della onhub nodo:
$ 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
Uscire dalla onhub nodo quando hai finito:
root@onhub:# exit
Tunnel di tessitura
Come il servizio simulato, è necessario impostare un tunnel Weave tra l'HAN simulato in Happy e il servizio. Con un vero servizio cloud, utilizza l'indirizzo IP o l'URL del servizio nella configurazione del tunnel. Per esempio:
$ weave-tunnel-start BorderRouter mycloud.service.com
9. Ripulire
È importante ripulire sempre le topologie Happy quando hai finito con loro, per evitare problemi con la configurazione della tua rete Linux.
Se è stato abilitato il supporto DNS nella topologia, rimuoverla eseguendo nuovamente il comando con il -d bandierina (cancellazione) prima. Questo deve essere eseguito prima che qualsiasi nodo Happy venga rimosso, per garantire che la configurazione di rete sia aggiornata correttamente.
$ happy-dns -d 172.16.255.1 172.16.255.153 172.16.255.53
Quindi, elimina lo stato Felice:
$ happy-state-delete
A volte, alcuni file di stato possono rimanere dopo l'eliminazione di uno stato. Se si esegue in problemi e Felice non funziona come previsto, eliminare lo stato con happy-state-delete e quindi utilizzare i seguenti comandi per forzare ogni residuo su pulito:
$ ip netns | xargs -I {} sudo ip netns delete {}
$ rm -rf ~/.*state.json
$ rm -rf ~/.*state.json.lock
La tua macchina dovrebbe tornare alla sua normale configurazione di rete.
10. Congratulazioni!
Ora sai:
- Come utilizzare Happy per simulare le proprie reti domestiche IoT
- Come connettere le topologie Happy a Internet
- Le basi di Weave tramite OpenWeave, la versione open source di Nest di Weave
Prossimi passi
Partendo da questo Codelab, prova i seguenti esercizi:
- Crea una topologia più ampia con più nodi in ogni Thread e rete Wi-Fi e stabilisci la connettività tra tutti i nodi
- Creare uno script bash per caricare la topologia tramite
happy-state-loado diweave-state-load - Esplora altri comandi felice, come
happy-tracerouteehappy-process-*
Ulteriori letture
Controllare openweave.io per una varietà di riferimenti, tra cui: