1. Introducción
Feliz es una herramienta creada por los laboratorios de Nest para la orquestación ligera de topologías de red simuladas. Happy es útil para el desarrollo y la prueba de redes de área doméstica de IoT.
Con Happy, puede:
- Pruebe protocolos de red y otros programas de ejecución distribuida en una sola máquina de desarrollo de Linux sin utilizar hardware de dispositivo IoT
- Realice pruebas funcionales automatizadas en una red
- Ejecute múltiples redes paralelas concurrentes en el mismo sistema para mejorar el rendimiento de las pruebas
En este experimento de código, usted aprenderá cómo empezar con Happy, así como los fundamentos de la armadura para los dispositivos IO. La implementación de la armadura que va a utilizar es OpenWeave , una versión de código abierto publicado por nido.
Lo que aprenderás
- Cómo construir Happy y OpenWeave
- Cómo crear manualmente una red de IoT simulada
- Cómo administrar topologías personalizadas
- Cómo conectar una red Happy simulada a Internet
- Los fundamentos de Weave
Lo que necesitarás
- Una máquina Linux, física o virtual
- Cliente de Git o cli
- Python 2.7
- Una comprensión básica de los conceptos de redes y enrutamiento.
2. Empiece
Instalar cadenas de herramientas y dependencias
Para construir Happy and Weave, asegúrese de tener una cadena de herramientas compatible y todas las dependencias instaladas.
$ 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
Obtén el código fuente
Clone los repositorios Happy y OpenWeave Git desde la línea de comando:
$ cd ~ $ git clone https://github.com/openweave/happy.git $ git clone https://github.com/openweave/openweave-core.git
Instalar Happy
Desde el directorio raíz de Happy, instale Happy:
$ cd ~/happy $ make
Verificar instalación feliz
Los comandos felices ahora deberían ser accesibles desde la línea de comandos:
$ happy-state State Name: happy NETWORKS Name Type State Prefixes NODES Name Interface Type IPs
Instalar OpenWeave
Desde el directorio raíz de OpenWeave, instale OpenWeave:
$ cd ~/openweave-core $ make -f Makefile-Standalone
Configurar Happy con OpenWeave
Para utilizar OpenWeave con Happy, debe informar a Happy dónde encontrar la instalación de Weave. Actualizar la configuración feliz con la ruta a /src/test-apps dentro de su estructura OpenWeave:
$ happy-configuration weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Confirma la configuración:
$ happy-configuration
User Happy Configuration
weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps
Verificar la instalación de OpenWeave
Se puede acceder a los comandos de tejido necesarios en este Codelab desde la línea de comandos:
$ 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 se obtiene el error weave-fabric-add: command not found , actualice su PATH variable de entorno con la ruta usada para Happy binarios:
$ export PATH=$PATH:~/openweave-core/src/test-apps/happy/bin
3. Tu primera topología
Creemos la siguiente topología de tres nodos con Happy.
Esta topología es un ejemplo de una red de área doméstica (HAN) simple. En este HAN, dos nodos están conectados juntos en una red Thread, y uno de esos nodos se conecta a un tercero a través de Wi-Fi. Este nodo también se puede conectar a un enrutador inalámbrico en el hogar para proporcionar conectividad a Internet para toda la HAN. Más sobre esto más adelante.
Primero, cree los tres nodos:
$ happy-node-add 01ThreadNode $ happy-node-add 02BorderRouter $ happy-node-add 03WiFiNode
Asegurémonos de que existan:
$ happy-node-list 01ThreadNode 02BorderRouter 03WiFiNode
Ahora creemos algunas redes:
$ happy-network-add ThreadNetwork thread $ happy-network-add WiFiNetwork wifi
Verifique que existan las redes:
$ happy-network-list ThreadNetwork WiFiNetwork
Compruebe el estado feliz:
$ happy-state
State Name: happy
NETWORKS Name Type State Prefixes
ThreadNetwork thread UP
WiFiNetwork wifi UP
NODES Name Interface Type IPs
01ThreadNode
02BorderRouter
03WiFiNode
No basta con poner en funcionamiento una red, tenemos que agregar nodos a las redes. Siguiendo nuestro diagrama de topología, agregue cada nodo a las redes apropiadas:
$ happy-node-join 01ThreadNode ThreadNetwork $ happy-node-join 02BorderRouter ThreadNetwork $ happy-node-join 02BorderRouter WiFiNetwork $ happy-node-join 03WiFiNode WiFiNetwork
Tenga en cuenta que 02BorderRouter se añadió a la vez ThreadNetwork y WiFiNetwork . Esto se debe a que, como Border Router dentro de nuestra HAN, este nodo conecta las dos redes individuales juntas.
Compruebe el estado feliz. Las interfaces de cada nodo están activas:
$ 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
Nuestra topología ahora se ve así:
El último paso para abrir nuestra red Happy es asignar direcciones IP a cada interfaz en cada nodo. Especifique el prefijo de IP de una red y Happy automáticamente le asignará direcciones de IP.
Debido a que el protocolo Thread usa IPv6, agregue un prefijo IPv6 a la red Thread:
$ happy-network-address ThreadNetwork 2001:db8:1:2::
Compruebe el estado feliz. Las interfaces de Thread en cada nodo de Thread tienen direcciones 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
Para la red WiFi, agregue los prefijos IPv4 e IPv6:
$ happy-network-address WiFiNetwork 2001:db8:a:b:: $ happy-network-address WiFiNetwork 10.0.1.0
Comprueba el estado Feliz una vez más. Todas las interfaces tienen direcciones IP asignadas, con dos para cada interfaz 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
Aquí está nuestra topología actualizada:
4. Pruebe la conectividad
Ahora que nuestra red feliz está en marcha, vamos a probar su conectividad haciendo ping a los otros nodos 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
Las happy-ping intentos de comando para hacer ping a cada dirección IP para cada interfaz en el nodo de destino. Podemos ignorar las direcciones IPv4 porque Thread solo usa IPv6.
Tenga en cuenta que sólo una de ping IPv6 tuvo éxito: el de 02BorderRouter 's wpan0 interfaz, que es la única dirección 01ThreadNode puede alcanzar directamente:
Las otras direcciones IPv6 fracasaron porque el reenvío no se ha habilitado entre wpan0 y wlan0 en 02BorderRouter . Por lo tanto, 01ThreadNode tiene ni idea de 03WiFiNode existe, o cómo llegar a ella. Happy ha sacado a relucir la red simulada, pero no ha habilitado todo el enrutamiento y reenvío entre nodos.
Agregar rutas
Para enrutar el tráfico IPv6 a través de la HAN, agregue las rutas adecuadas a cada nodo de cada red, en ambas direcciones (para que el ping sepa cómo regresar al nodo de origen).
Para cada nodo, necesitará saber:
- la red más cercana puerta de entrada, en este caso,
02BorderRouterpara ambos - la red de destino: adónde ir después de la puerta de enlace
Para nuestra red de tres nodos, eso nos da lo siguiente:
de la red de origen | a la red de destino | a través de Gateway |
| | |
| | |
Esto se puede hacer de forma individual para cada nodo con happy-node-route , pero es más fácil que hacerlo por todos los nodos de cada red 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
Para una explicación de las opciones de la línea de comandos, utilice happy-network-route -h .
La happy-network-route comando también se activa el reenvío de IPv4 e IPv6 para cada nodo, según sea necesario. Esto permite que el tráfico se enrute de una interfaz a otra dentro de un nodo.
Ahora vuelva a intentar el 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
¡Ambos pings IPv6 funcionan! Con el redireccionamiento, que sabe cómo llegar a la wlan0 interfaz. El ping de IPv4 aún falla, porque solo configuramos las rutas y el reenvío de IPv6 (también porque Thread no se ejecuta en IPv4).
Dado que agregamos rutas de red a ambos lados, hagamos ping a través de las redes:
$ 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
El ping de IPv6 funciona como se esperaba. Ahora tiene una HAN IPv6 simulada y completamente funcional.
Para permitir una forma más segura y confiable de conectar todo, agreguemos Weave en la parte superior del HAN.
5. Agregar tejido
Weave es una capa de aplicación de red que proporciona la columna vertebral de comunicaciones segura y confiable para los productos Nest. Podemos agregar la funcionalidad Weave con OpenWeave, la versión de código abierto de Weave.
Una implementación de Weave se denomina "tejido". Un tejido Weave es una red que comprende todos los nodos HAN, el Servicio Nest y cualquier dispositivo móvil que participe en la HAN. Se asienta sobre el HAN y permite un enrutamiento más fácil a través de las diferentes tecnologías de enlace de red subyacentes (por ejemplo, Thread o Wi-Fi).
Crear el tejido de ligamento para su HAN, utilizando fab1 como el ID Tela, a continuación, configurar todos los nodos de la armadura:
$ weave-fabric-add fab1 $ weave-node-configure
Ahora que Weave está configurado, verifique el estado Feliz:
$ 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
Cada nodo se ha añadido a la tela de la armadura, y cada interfaz tiene una nueva dirección IPv6 a partir de fd00 . Para obtener más información sobre el tejido de la armadura, utilice el weave-state de comandos:
$ 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
Aquí está nuestra topología actualizada, con los valores de Weave en azul:
Tejido de tejido
Hay mucha información nueva en los estados Weave y Happy. Empecemos con la tela de weave-state :
FABRIC Fabric Id Global Prefix
fab1 fd00:0000:fab1::/48
Usos de la armadura de un prefijo IPv6 de fd00::/48 para cada nodo. Las direcciones de este bloque se denominan direcciones locales únicas y están diseñadas para su uso en redes privadas como una HAN. La combinación de eso con el ID de la tela genera el Prefijo global de tejido que se muestra arriba.
Nodos de tejido
A cada nodo del tejido Weave se le asigna un ID de nodo único, junto con un código de emparejamiento:
NODES Name Weave Node Id Pairing Code
01ThreadNode 69ca9502eb6911e7 8ZJB5Q
02BorderRouter 686af236eb6911e7 B5YV3P
03WiFiNode 69826e60eb6911e7 L3VT3A
El ID de nodo identifica globalmente un nodo en el tejido Weave. El código de emparejamiento se utiliza como una "credencial de unión" durante el proceso de emparejamiento y, por lo general, se imprime junto con el código QR de un producto.
Por ejemplo, si observa el código QR en un Nest Protect o una Nest Cam, notará una cadena de 6 caracteres, a menudo denominada Clave de entrada. Este es el código de emparejamiento de tejido.
Weave utiliza una combinación del prefijo global, el ID de la estructura y la ID del nodo para crear direcciones IPv6 específicas de Weave para cada nodo e interfaz en la estructura.
Tejer direcciones
Tenga en cuenta que hay cuatro nuevas direcciones IPv6 en la topología feliz, todo a partir de nuestra armadura de Global Prefijo 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
Los protocolos Weave utilizan estas direcciones para comunicarse a través del tejido Weave, en lugar de las direcciones IPv6 estándar asignadas a cada nodo.
Pasarela de red de tejido
Los nodos de tejido en una red Thread necesitan saber por dónde salir de esa red. Una puerta de enlace de red Weave, generalmente en un enrutador de borde de subprocesos, proporciona esta funcionalidad.
En nuestra topología de muestra, designemos el nodo BorderRouter como la puerta de enlace de la red Weave:
$ weave-network-gateway ThreadNetwork 02BorderRouter
Este comando agrega una ruta de todos los nodos de rosca a la subred tejido de ligamento ( fd:0:fab1::/48 ) a través de la BorderRouter interfaz de hilo de nodo ( wpan0 ), que permite a cada nodo del hilo para llegar a cualquier nodo de la armadura más allá de la red de rosca. Esto es análogo a la happy-network-route comando hemos usado anteriormente, pero adaptadas a las rutas de tejido de ligamento.
6. Mantenimiento de topología
Lo que hace que Happy sea tan poderoso es la facilidad con la que administra toda la configuración y el desmontaje de una topología simulada.
Guarde su topología Happy para su uso posterior:
$ happy-state -s codelab.json
Esto coloca un archivo JSON con la topología completa de la raíz de su ~/ carpeta. El archivo JSON es una copia de su estado de felicidad actual, que se encuentra en ~/.happy_state.json .
Una vez guardado, elimine la topología actual:
$ happy-state-delete
Esto elimina todos los espacios de nombres de red y configuraciones relacionados que se encuentran en el ~/.happy-state.json archivo. Compruebe happy-state y la weave-state para confirmar una configuración vacío:
$ 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
Para recargar una configuración guardada, use uno de dos comandos:
-
happy-state-load- no soporta plug-in de la armadura -
weave-state-load- soportes de plugin Weave
Así que si la topología incluye la armadura, utilice siempre la weave-state-load de comandos para que se aplica el tejido de la armadura y la configuración asociada.
Vuelva a cargar la topología Happy guardada:
$ weave-state-load codelab.json
Verifique todos los estados para confirmar una carga exitosa:
$ 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
Se han proporcionado varias topologías predefinidas en el repositorio Happy, tanto en formato shell-script como en formato JSON. Se consiguen en ~/happy/topologies .
OpenWeave también viene con topologías Happy predefinidas seleccionadas para propósitos de prueba. Se consiguen en ~/openweave-core/src/test-apps/happy/topologies/standalone .
7. Cómo funciona
Happy usa espacios de nombres de red de Linux para simular topologías complejas. Normalmente, una configuración de red se aplica a todo el sistema operativo Linux. Los espacios de nombres de red le permiten particionar configuraciones de red para que cada espacio de nombres tenga su propio conjunto de interfaces y tablas de enrutamiento.
Cada nodo y red en Happy es un espacio de nombres de red, mientras que los enlaces entre ellos son interfaces de red.
Por ejemplo, usando nuestra topología:
Veamos qué espacios de nombres creó Happy para esto:
$ ip netns list happy004 happy003 happy002 happy001 happy000
Si marca la netns sección del archivo JSON estado feliz, se puede ver lo que los nodos y redes de cada espacio de nombres corresponde a:
$ happy-state -j | grep "netns" -A 5
"netns": {
"01ThreadNode": "000",
"02BorderRouter": "001",
"03WiFiNode": "002",
"ThreadNetwork": "003",
"WiFiNetwork": "004",
Registros de tiempo de ejecución
Los comandos emitidos a los nodos son comandos de terminal básicos que se ejecutan desde el espacio de nombres de cada nodo. Una forma fácil de ver esto es habilitar los registros de tiempo de ejecución Happy.
Abra una segunda ventana de terminal y encienda los registros, se ejecutarán continuamente en esta ventana:
$ happy-state -l
Regrese a la primera ventana y ejecute un ping feliz:
$ happy-ping 01ThreadNode 02BorderRouter
Verifique las entradas de registro más recientes en la segunda ventana de terminal. Debería ver una línea como esta en los registros:
DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ping6 -c 1 2001:0db8:0001:0002:5e53:bbff:fe05:484b
El happy-ping comando no es más que feliz de ejecutar el ping6 comando en el happy000 espacio de nombres ( 01ThreadNode ).
Entrar en un nodo
Utilice happy-shell para ejecutar comandos no felices como si ha iniciado sesión en uno de los nodos (espacios de nombres de red):
$ happy-shell 01ThreadNode root@01ThreadNode:#
Los dispositivos simulados se ejecutan dentro de cada espacio de nombres y solo tienen acceso a la configuración de red especificada a través de Happy.
Verifique la configuración de la interfaz del nodo. Esto será diferente a la configuración de todo el sistema operativo y debería reflejar lo que se enumera en el estado Feliz:
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)
Utilice exit para dejar espacio de nombres del nodo:
root@01ThreadNode:# exit
8. Conéctese a un servicio
Con una comprensión de cómo Happy usa los espacios de nombres de red de Linux, ahora puede darse cuenta de que es posible conectar una red Happy simulada a Internet y acceder a direcciones públicas desde nodos simulados. Esto es útil para conectar sus dispositivos simulados a un servicio real (como el Servicio Nest sobre Weave).
El servicio en Weave es una infraestructura basada en la nube que conecta los nodos HAN en un modelo de datos, proporciona acceso remoto e implementa controladores inteligentes para crear un ecosistema integral.
El servicio se puede representar de dos formas principales con Happy:
- Como un servicio simulado en su propio espacio de nombres de red (nodo Happy)
- Como un verdadero servicio en la nube en Internet
Topologías predefinidas se han proporcionado en ~/happy/topologies como un ejemplo de cada escenario servicio.
Servicio simulado en un nodo Happy
Elimine las topologías Happy existentes:
$ happy-state-delete
Confirmar un estado vacío con las happy-state y la weave-state comandos.
Cargue una topología predefinida con punto de acceso (AP) y nodos de servicio:
$ weave-state-load ~/happy/topologies/thread_wifi_ap_service.json
Compruebe los estados Happy y Weave para confirmar la topología. En esta topología, onhub es el punto de acceso, mientras que cloud es el servicio simulado. Nota Ambos están conectados a un Internet la red de 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
Túnel de tejido
Un túnel Weave conecta la tela Weave a un servicio. Esta es una ruta segura que transfiere mensajes IPv6 UDP entre el HAN y el servicio. En esta topología, el BorderRouter nodo es la pasarela de red de la armadura, que funciona como el punto final del túnel en la HAN.
Crea el túnel de tejido:
$ weave-tunnel-start BorderRouter cloud
Vuelva a comprobar el estado Feliz. Debería ver una nueva interfaz de túnel con una dirección IPv6 de la armadura en la 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
Ahora puede hacer ping correctamente entre los nodos del tejido Weave y el prefijo global Weave del servicio:
$ happy-ping ThreadNode cloud
[Ping] ping from ThreadNode to cloud on address
fd00:0000:fab1:0005:1ab4:3002:0000:0011 -> 0% packet loss
Servicio de nube real en Internet
Elimine las topologías Happy existentes:
$ happy-state-delete
Confirmar un estado vacío con las happy-state y la weave-state comandos.
Cargue una topología predefinida con un nodo de punto de acceso (AP):
$ weave-state-load ~/happy/topologies/thread_wifi_ap_internet.json
En esta topología, onhub es el punto de acceso. Compruebe el estado feliz. Es similar a la topología anterior, sin la Internet de la red y cloud de 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
Dado que cada nodo Happy es un espacio de nombres de red, están particionados de la Internet pública de forma predeterminada. Pruebe esto ingresando un nodo Feliz y haciendo ping a una dirección pública de Internet. Usaremos 8.8.8.8 , una de las direcciones IPv4 de Google.com.
$ happy-shell onhub root@onhub:# ping -c2 8.8.8.8 connect: Network is unreachable
Para conectar el onhub nodo a internet, debe ser superada para que la interfaz de la configuración del nivel de sistema operativo Linux.
Salga del nodo:
root@onhub:# exit
Determinar la interfaz para su conexión a internet con la route de comandos:
$ 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
Encontrar el default ruta. Esta es la conexión a Internet para su máquina Linux. El Iface columna indica qué interfaz se utiliza para que la conectividad. En el ejemplo anterior, es em1 .
Utilice happy-internet para configurar el puente, utilizando la interfaz de la ruta por defecto. Para el --isp bandera, utilizar el nombre de la interfaz sin números de salida. En este ejemplo, es em . Si su interfaz por defecto es eth1 , la --isp bandera sería eth .
$ happy-internet --node onhub --interface em1 --isp em --seed 249
No habrá ningún cambio visible en el happy-state de salida, pero el onhub nodo debe tener conectividad a Internet. Regresemos al nodo y verifiquemos:
$ 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
¡Éxito!
DNS
Los nodos felices no tienen capacidades de DNS integradas. Si intenta hacer ping a google.com, falla:
root@onhub:# ping -c2 google.com ping: unknown host google.com
Afortunadamente, Happy brinda soporte para DNS. Salga del nodo y busque los servidores DNS para su máquina Linux. Asegúrese de utilizar la interfaz predeterminada adecuada:
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
Con estas direcciones DNS con happy-dns :
$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53
Ahora intenta hacer ping a google.com desde dentro de la 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
Salir del onhub nodo cuando haya terminado:
root@onhub:# exit
Túnel de tejido
Al igual que el servicio simulado, se debe instalar un túnel Weave entre el HAN simulado en Happy y el servicio. Con un servicio en la nube real, use la dirección IP o URL del servicio en la configuración del túnel. Por ejemplo:
$ weave-tunnel-start BorderRouter mycloud.service.com
9. Limpieza
Es importante limpiar siempre las topologías Happy cuando haya terminado con ellas, para evitar problemas con la configuración de su red Linux.
Si ha habilitado el soporte de DNS en su topología, y eliminar volviendo a ejecutar ese comando con el -d bandera (delete) en primer lugar. Esto debe ejecutarse antes de que se eliminen los nodos Happy, para garantizar que la configuración de red se actualice correctamente.
$ happy-dns -d 172.16.255.1 172.16.255.153 172.16.255.53
A continuación, elimine el estado Feliz:
$ happy-state-delete
Ocasionalmente, algunos archivos de estado pueden permanecer después de una eliminación de estado. Si se encuentra con problemas y no funciona como se esperaba feliz, eliminar el estado con happy-state-delete y luego usar los siguientes comandos para forzar la limpieza de cualquier restante:
$ ip netns | xargs -I {} sudo ip netns delete {}
$ rm -rf ~/.*state.json
$ rm -rf ~/.*state.json.lock
Su máquina debería volver a su configuración de red normal.
10. ¡Felicitaciones!
Ahora sabes:
- Cómo utilizar Happy para simular sus propias redes de área doméstica de IoT
- Cómo conectar topologías Happy a Internet
- Los conceptos básicos de Weave a través de OpenWeave, la versión de código abierto de Nest de Weave
Próximos pasos
Partiendo de este Codelab, pruebe los siguientes ejercicios:
- Cree una topología más grande con múltiples nodos en cada Thread y red Wi-Fi, y establezca conectividad entre todos los nodos.
- Crear un script bash para cargar la topología a través
happy-state-loadoweave-state-load - Explora otros comandos felices, como
happy-tracerouteyhappy-process-*
Otras lecturas
Compruebe openweave.io para una variedad de referencias, incluyendo: