En Google, luchamos por la equidad racial de la comunidad negra. Más información
Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Empezando con Happy y Weave

Happy es una herramienta creada por Nest Labs 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 usar 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 Codelab, aprenderá cómo comenzar con Happy, así como los conceptos básicos de Weave para dispositivos IoT. La implementación de Weave que usará es OpenWeave , una versión de código abierto lanzada por Nest.

f6996428fb06dede.png

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.

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. Actualice la configuración de Happy con la ruta a /src/test-apps dentro de su compilación de 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

Los comandos de tejido necesarios en este Codelab son accesibles 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 obtiene el error weave-fabric-add: command not found , actualice su PATH entorno PATH con la ruta utilizada para los binarios Happy:

$ export PATH=$PATH:~/openweave-core/src/test-apps/happy/bin

Creemos la siguiente topología de tres nodos con Happy.

a3295ee87fbd9764.png

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 todo el 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 agregó a ThreadNetwork y WiFiNetwork . Esto se debe a que, como Border Router dentro de nuestro 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í:

2d054e6c4e54089c.png

El último paso para abrir nuestra red Happy es asignar direcciones IP a cada interfaz en cada nodo. Especifique el prefijo de IP para una red y Happy automáticamente le asignará direcciones 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

Compruebe 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:

84eecd23871618ca.png

Ahora que nuestra red Happy está en funcionamiento, 01ThreadNode 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

El comando happy-ping intenta 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:

5447bcbdf7d539df.png

Las otras direcciones IPv6 fallaron porque el reenvío no se habilitó entre wpan0 y wlan0 en 02BorderRouter . Por lo tanto, 01ThreadNode no tiene idea de que existe 03WiFiNode , o cómo llegar a él. Happy ha mostrado 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 en cada red, en ambas direcciones (para que el ping sepa cómo regresar al nodo de origen).

Para cada nodo, necesitará saber:

  • la puerta de enlace de red más cercana; en este caso, 02BorderRouter para 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

ThreadNetwork

WiFiNetwork

02BorderRouter wlan0 2001:db8:1:2::/64 prefix

WiFiNetwork

ThreadNetwork

02BorderRouter wpan0 2001:db8:a:b::/64 prefix

Esto se puede hacer individualmente para cada nodo con happy-node-route , pero es más fácil hacerlo para 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 obtener una explicación de los indicadores de la línea de comandos, use happy-network-route -h .

El comando happy-network-route también 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 reenvío wlan0 , sabe cómo llegar a la interfaz wlan0 . 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 sobre 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.

5bb53be0280b3320.png

Para permitir una forma más segura y confiable de conectar todo, agreguemos Weave encima del HAN.

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 el 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).

Cree el tejido Weave para su HAN, utilizando fab1 como ID de tejido, luego configure todos los nodos para Weave:

$ 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 agregado a la estructura Weave y cada interfaz tiene una nueva dirección IPv6 que comienza con fd00 . Para obtener más información sobre la tela Weave, use el comando weave-state :

$ 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:

ce3fa9082408355b.png

Tejido de tejido

Hay mucha información nueva en los estados Weave y Happy. Comencemos con la tela del weave-state de weave-state :

FABRIC     Fabric Id           Global Prefix
                fab1     fd00:0000:fab1::/48

Weave usa 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 normalmente 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.

e7c6fa3e24d61d1b.png

Weave utiliza una combinación del Prefijo global, la 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 Happy, todas comenzando con nuestro Prefijo global de fd00:0000:fab1::/48 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, normalmente 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 al comando happy-network-route que usamos anteriormente, pero específico para las rutas de tejido de Weave.

Lo que hace que Happy sea tan poderoso es la facilidad con 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 en su carpeta raíz ~/ . El archivo JSON es una copia de su estado Happy 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 las configuraciones relacionadas que se encuentran en el archivo ~/.happy-state.json . Compruebe happy-state weave-state para confirmar una configuración vacía:

$ 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 es compatible con el complemento Weave
  • weave-state-load - admite el complemento Weave

Por tanto, si su topología incluye Weave, utilice siempre el comando weave-state-load para que se aplique el tejido Weave 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 una serie de topologías predefinidas en el repositorio Happy, tanto en formato shell-script como JSON. Encuéntrelos en ~/happy/topologies .

OpenWeave también viene con topologías Happy predefinidas seleccionadas para propósitos de prueba. Encuéntrelos en ~/openweave-core/src/test-apps/happy/topologies/standalone .

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 las 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:

7d6654c2e4907f2a.png

Veamos qué espacios de nombres creó Happy para esto:

$ ip netns list
happy004
happy003
happy002
happy001
happy000

Si verifica la sección netns del archivo JSON de estado feliz, puede ver a qué nodos y redes corresponde cada espacio de nombres:

$ happy-state -j | grep "netns" -A 5
"netns": {
    "01ThreadNode": "000",
    "02BorderRouter": "001",
    "03WiFiNode": "002",
    "ThreadNetwork": "003",
    "WiFiNetwork": "004",

49cfdce6ff9dd745.png

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

Use happy-shell para ejecutar happy-shell que no sean Happy como si hubiera 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.

Compruebe 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 aparece 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)

Use exit para salir del espacio de nombres del nodo:

root@01ThreadNode:# exit

Una vez que comprenda 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

Se han proporcionado topologías predefinidas en ~/happy/topologies como ejemplo de cada escenario de servicio.

Servicio simulado en un nodo Happy

Elimine las topologías Happy existentes:

$ happy-state-delete

Confirme un estado vacío con los comandos happy-state y weave-state .

Cargue una topología predefinida con punto de acceso (AP) y nodos de servicio:

$ weave-state-load ~/happy/topologies/thread_wifi_ap_service.json

6d04cbfcc84038e2.png

Compruebe los estados Happy y Weave para confirmar la topología. En esta topología, onhub es el AP, mientras que la cloud es el servicio simulado. Tenga en cuenta que ambos están conectados a una red de Internet 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 nodo BorderRouter es la puerta de enlace de la red Weave, 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 Weave en el nodo de la cloud :

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

c5ffca09d7cd3208.png

Ahora puede hacer ping con éxito 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

Confirme un estado vacío con los comandos happy-state y weave-state .

Cargue una topología predefinida con un nodo de punto de acceso (AP):

$ weave-state-load ~/happy/topologies/thread_wifi_ap_internet.json

c75127417ef3833a.png

En esta topología, onhub es el AP. Compruebe el estado feliz. Es similar a la topología anterior, sin la red de Internet ni el nodo en la cloud :

$ 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 por defecto. 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 nodo onhub a Internet, debe conectarse a esa interfaz en la configuración de nivel de sistema operativo Linux.

Salga del nodo:

root@onhub:# exit

Determine la interfaz para su conexión a Internet con el comando route :

$ 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

Encuentra la ruta default . Esta es la conexión a Internet para su máquina Linux. La columna Iface indica qué interfaz se está utilizando para esa conectividad. En el ejemplo anterior, es em1 .

Use happy-internet para configurar el puente, usando la interfaz para su ruta predeterminada. Para el indicador --isp , use el nombre de la interfaz sin números finales. En este ejemplo, son em . Si su interfaz predeterminada es eth1 , el indicador --isp sería eth .

$ happy-internet --node onhub --interface em1 --isp em --seed 249

No habrá ningún cambio visible en la salida de happy-state , pero el nodo onhub debería 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!

c4d411ab1734131.png

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

Utilice estas direcciones DNS con happy-dns :

$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53

Ahora intente hacer ping a google.com desde el nodo onhub :

$ 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

Salga del nodo onhub cuando haya terminado:

root@onhub:# exit

Túnel de tejido

Al igual que el servicio simulado, se debe configurar 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

3ed2c3c0df67f4d2.png

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 habilitó la compatibilidad con DNS en su topología, elimínela volviendo a ejecutar ese comando con la -d (eliminar) primero . 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 tiene problemas y Happy no funciona como se esperaba, elimine el estado con happy-state-delete y luego use los siguientes comandos para forzar cualquier limpieza 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.

Ahora sabes:

  • Cómo utilizar Happy para simular sus propias redes de área doméstica de IoT
  • Cómo conectar las 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
  • Cree un script bash para cargar la topología a través de happy-state-load o weave-state-load
  • Explore otros comandos de Happy, como happy-traceroute y happy-process-*

Otras lecturas

Consulte openweave.io para obtener una variedad de referencias, que incluyen:

f6996428fb06dede.png