O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.
Esta página foi traduzida pela API Cloud Translation.
Switch to English

Primeiros passos com Happy e Weave

Happy é uma ferramenta criada pelos laboratórios Nest para orquestração leve de topologias de rede simuladas. Happy é útil para o desenvolvimento e teste de redes de área doméstica IoT.

Com o Happy, você pode:

  • Testar protocolos de rede e outros programas de execução distribuída em uma única máquina de desenvolvimento Linux sem usar hardware de dispositivo IoT
  • Realize testes funcionais automatizados em uma rede
  • Execute várias redes paralelas e simultâneas no mesmo sistema para melhorar o rendimento do teste

Neste Codelab, você aprenderá como começar a usar o Happy, bem como os fundamentos do Weave para dispositivos IoT. A implementação do Weave que você usará é o OpenWeave , uma versão de código aberto lançada pela Nest.

f6996428fb06dede.png

O que você aprenderá

  • Como construir Happy e OpenWeave
  • Como criar manualmente uma rede IoT simulada
  • Como gerenciar topologias personalizadas
  • Como conectar uma rede simulada Happy à internet
  • O básico do Weave

O que você precisará

  • Uma máquina Linux, física ou virtual
  • Cliente Git ou cli
  • Python 2.7
  • Uma compreensão básica dos conceitos de rede e roteamento

Instale o conjunto de ferramentas e dependências

Para construir o Happy e o Weave, certifique-se de ter um conjunto de ferramentas compatível e todas as dependências 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

Obtenha o código-fonte

Clone os repositórios Happy e OpenWeave Git a partir da linha de comando:

$ cd ~
$ git clone https://github.com/openweave/happy.git
$ git clone https://github.com/openweave/openweave-core.git

Instale Happy

No diretório raiz do Happy, instale o Happy:

$ cd ~/happy
$ make

Verificar instalação feliz

Os comandos felizes agora devem estar acessíveis na linha de comando:

$ happy-state
State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes

NODES      Name    Interface    Type                                          IPs

Instale OpenWeave

No diretório raiz do OpenWeave, instale o OpenWeave:

$ cd ~/openweave-core
$ make -f Makefile-Standalone

Configure Happy com OpenWeave

Para usar o OpenWeave com Happy, você precisa informar Happy onde encontrar a instalação do Weave. Atualize a configuração Happy com o caminho para /src/test-apps dentro de sua compilação OpenWeave:

$ happy-configuration weave_path ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps

Confirme a configuração:

$ happy-configuration
User Happy Configuration
        weave_path         ~/openweave-core/build/x86_64-unknown-linux-gnu/src/test-apps

Verifique a instalação do OpenWeave

Os comandos Weave necessários neste Codelab podem ser acessados ​​na linha de 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 você receber o erro weave-fabric-add: command not found , atualize sua variável de ambiente PATH com o caminho usado para binários Happy:

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

Vamos criar a seguinte topologia de três nós com Happy.

a3295ee87fbd9764.png

Esta topologia é um exemplo de uma Rede de Área Doméstica (HAN) simples. Neste HAN, dois nós são conectados juntos em uma rede Thread, e um desses nós se conecta a um terceiro via Wi-Fi. Esse nó também pode ser conectado a um roteador sem fio em casa para fornecer conectividade à Internet para todo o HAN. Mais sobre isso mais tarde.

Primeiro, crie os três nós:

$ happy-node-add 01ThreadNode
$ happy-node-add 02BorderRouter
$ happy-node-add 03WiFiNode

Vamos ter certeza de que eles existem:

$ happy-node-list
01ThreadNode
02BorderRouter
03WiFiNode

Agora vamos criar algumas redes:

$ happy-network-add ThreadNetwork thread
$ happy-network-add WiFiNetwork wifi

Verifique se as redes existem:

$ happy-network-list
ThreadNetwork
WiFiNetwork

Verifique o estado de 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

Não é suficiente apenas criar uma rede - temos que adicionar nós às redes. Seguindo nosso diagrama de topologia, adicione cada nó à (s) rede (s) apropriada (s):

$ happy-node-join 01ThreadNode ThreadNetwork
$ happy-node-join 02BorderRouter ThreadNetwork
$ happy-node-join 02BorderRouter WiFiNetwork
$ happy-node-join 03WiFiNode WiFiNetwork

Observe que 02BorderRouter foi adicionado a ThreadNetwork e WiFiNetwork . Isso porque, como um roteador de fronteira em nosso HAN, esse nó conecta as duas redes individuais.

Verifique o estado de Feliz. As interfaces de cada nó estão ativas:

$ 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

Nossa topologia agora se parece com isto:

2d054e6c4e54089c.png

A última etapa para trazer nossa rede Happy é atribuir endereços IP a cada interface em cada nó. Especifique o prefixo IP para uma rede, e Happy atribui endereços IP automaticamente para você.

Como o protocolo Thread usa IPv6, adicione um prefixo IPv6 à rede Thread:

$ happy-network-address ThreadNetwork 2001:db8:1:2::

Verifique o estado de Feliz. As interfaces Thread em cada nó Thread têm endereços 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 a rede WiFi, adicione os prefixos IPv4 e IPv6:

$ happy-network-address WiFiNetwork 2001:db8:a:b::
$ happy-network-address WiFiNetwork 10.0.1.0

Verifique o estado feliz mais uma vez. Todas as interfaces têm endereços IP atribuídos, com dois para cada interface Wi-Fi:

$ happy-state

State Name:  happy

NETWORKS   Name         Type   State                                     Prefixes
  ThreadNetwork       thread      UP                       2001:0db8:0001:0002/64

    WiFiNetwork         wifi      UP                       2001:0db8:000a:000b/64
                                                                        10.0.1/24


NODES      Name    Interface    Type                                          IPs
   01ThreadNode        wpan0  thread   2001:0db8:0001:0002:3e36:13ff:fe33:732e/64

 02BorderRouter        wpan0  thread   2001:0db8:0001:0002:a651:3eff:fe92:6dbc/64

                       wlan0    wifi                                  10.0.1.2/24
                                       2001:0db8:000a:000b:426c:38ff:fe90:01e6/64

     03WiFiNode        wlan0    wifi   2001:0db8:000a:000b:9aae:2bff:fe71:62fa/64
                                                                      10.0.1.3/24

Aqui está nossa topologia atualizada:

84eecd23871618ca.png

Agora que nossa rede Happy está instalada e funcionando, vamos testar sua conectividade executando ping nos outros nós 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

O comando happy-ping tenta executar ping em todos os endereços IP de todas as interfaces no nó de destino. Podemos ignorar os endereços IPv4 porque o Thread usa apenas IPv6.

Note-se que apenas um de ping IPv6 foi bem sucedida: um à 02BorderRouter 's wpan0 interface, que é o único endereço 01ThreadNode pode atingir diretamente:

5447bcbdf7d539df.png

Os outros endereços IPv6 falharam porque o encaminhamento não foi ativado entre wpan0 e wlan0 em 02BorderRouter . Assim, 01ThreadNode não tem ideia de que 03WiFiNode existe, ou como alcançá-lo. Happy trouxe a rede simulada, mas não habilitou todo o roteamento e encaminhamento entre nós.

Adicionar rotas

Para rotear o tráfego IPv6 através do HAN, adicione as rotas adequadas para cada nó em cada rede, em ambas as direções (para que o ping saiba como retornar ao nó de origem).

Para cada nó, você precisa saber:

  • o gateway de rede mais próximo - neste caso, 02BorderRouter para ambos
  • a rede de destino - para onde ir depois do gateway

Para nossa rede de três nós, isso nos dá o seguinte:

da rede de origem

para a rede de destino

via gateway

ThreadNetwork

WiFiNetwork

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

WiFiNetwork

ThreadNetwork

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

Isso pode ser feito individualmente para cada nó com happy-node-route , mas é mais fácil de fazer para todos os nós em cada rede com 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 obter uma explicação sobre os sinalizadores de linha de comando, use happy-network-route -h .

O comando happy-network-route também ativa o encaminhamento IPv4 e IPv6 para cada nó, conforme necessário. Isso permite que o tráfego seja roteado de uma interface para outra dentro de um nó.

Agora tente novamente o 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 os pings IPv6 funcionam! Com o encaminhamento ativado, ele sabe como acessar a interface wlan0 . O ping IPv4 ainda falha, porque configuramos apenas as rotas e encaminhamentos IPv6 (também porque o Thread não roda em IPv4).

Como adicionamos rotas de rede para ambos os lados, vamos fazer ping nas 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

O ping IPv6 funciona conforme o esperado. Agora você tem um HAN IPv6 simulado totalmente funcional.

5bb53be0280b3320.png

Para permitir uma maneira mais segura e confiável de conectar tudo, vamos adicionar Weave na parte superior do HAN.

Weave é uma camada de aplicativo de rede que fornece o backbone de comunicações seguro e confiável para os produtos Nest. Podemos adicionar a funcionalidade do Weave com o OpenWeave, a versão de código aberto do Weave.

Uma implementação do Weave é chamada de "tecido". Um tecido Weave é uma rede que compreende todos os nós HAN, o serviço Nest e quaisquer dispositivos móveis participantes do HAN. Ele fica em cima do HAN e permite um roteamento mais fácil entre as diferentes tecnologias de link de rede subjacentes (por exemplo, Thread ou Wi-Fi).

Crie o tecido Weave para o seu HAN, usando fab1 como o ID do Fabric e, em seguida, configure todos os nós para Weave:

$ weave-fabric-add fab1
$ weave-node-configure

Agora que o Weave está configurado, verifique o 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 nó foi adicionado ao tecido Weave e cada interface tem um novo endereço IPv6 começando com fd00 . Para obter mais informações sobre o tecido Weave, use o 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

Aqui está nossa topologia atualizada, com valores Weave em azul:

ce3fa9082408355b.png

Tecido

Há muitas informações novas nos estados Weave e Happy. Vamos começar com o tecido do weave-state de weave-state :

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

Weave usa um prefixo IPv6 de fd00::/48 para cada nó. Os endereços neste bloco são chamados de endereços locais exclusivos e são designados para uso em redes privadas, como uma HAN. Combinar isso com o ID do Fabric gera o prefixo Weave Global mostrado acima.

Nós de trama

Cada nó no tecido Weave é atribuído a um ID de nó exclusivo, juntamente com um código de emparelhamento:

NODES           Name       Weave Node Id    Pairing Code
        01ThreadNode    69ca9502eb6911e7          8ZJB5Q
      02BorderRouter    686af236eb6911e7          B5YV3P
          03WiFiNode    69826e60eb6911e7          L3VT3A

O Node ID identifica globalmente um nó no tecido Weave. O código de emparelhamento é usado como uma "credencial de junção" durante o processo de emparelhamento e normalmente seria impresso junto com o código QR de um produto.

Por exemplo, se você olhar o código QR em um Nest Protect ou Nest Cam, você notará uma string de 6 caracteres, geralmente chamada de Entry Key. Este é o Código de emparelhamento de Weave.

e7c6fa3e24d61d1b.png

O Weave usa uma combinação do Prefixo Global, do Fabric ID e do Node ID para criar endereços IPv6 específicos do Weave para cada nó e interface no fabric.

Endereços de tecelagem

Observe que há quatro novos endereços IPv6 na topologia Happy, todos começando com nosso prefixo Weave Global 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

Os protocolos Weave usam esses endereços para se comunicarem na malha Weave, em vez dos endereços IPv6 padrão atribuídos a cada nó.

Gateway de rede Weave

Os nós do Weave em uma rede Thread precisam saber onde sair dessa rede. Um gateway de rede Weave - normalmente em um Thread Border Router - fornece essa funcionalidade.

Em nossa topologia de amostra, vamos designar o nó BorderRouter como o gateway de rede Weave:

$ weave-network-gateway ThreadNetwork 02BorderRouter

Este comando adiciona uma rota de todos os nós thread para a sub-rede tecido Weave ( fd:0:fab1::/48 ) por meio do BorderRouter interface do fio de nó ( wpan0 ), que permite que cada nó da linha para chegar a qualquer nó Weave além da rede Thread. Isso é análogo ao comando happy-network-route que usamos anteriormente, mas específico para rotas de tecido Weave.

O que torna o Happy tão poderoso é como ele gerencia facilmente toda a configuração e desmontagem de uma topologia simulada.

Salve sua topologia Happy para uso posterior:

$ happy-state -s codelab.json

Isso coloca um arquivo JSON com a topologia completa em sua pasta raiz ~/ . O arquivo JSON é uma cópia do seu estado Happy atual, que pode ser encontrado em ~/.happy_state.json .

Depois de salvo, exclua a topologia atual:

$ happy-state-delete

Isso exclui todos os namespaces de rede e configurações relacionadas encontradas no arquivo ~/.happy-state.json . Verifique happy-state e weave-state para confirmar uma configuração vazia:

$ 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 recarregar uma configuração salva, use um dos dois comandos:

  • happy-state-load - não suporta plugin Weave
  • weave-state-load - suporta o plugin Weave

Portanto, se sua topologia incluir Weave, sempre use o comando weave-state-load para que a malha Weave e a configuração associada sejam aplicadas.

Recarregue a topologia feliz salva:

$ weave-state-load codelab.json

Verifique todos os estados para confirmar um carregamento bem-sucedido:

$ 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

Uma série de topologias predefinidas foram fornecidas no repositório Happy, em ambos os formatos shell-script e JSON. Encontre-os em ~/happy/topologies .

O OpenWeave também vem com topologias Happy predefinidas selecionadas para fins de teste. Encontre-os em ~/openweave-core/src/test-apps/happy/topologies/standalone .

Happy usa namespaces de rede Linux para simular topologias complexas. Normalmente, uma configuração de rede se aplica a todo o sistema operacional Linux. Os namespaces de rede permitem que você particione as configurações de rede para que cada namespace tenha seu próprio conjunto de interfaces e tabelas de roteamento.

Cada nó e rede no Happy é um namespace de rede, enquanto os links entre eles são interfaces de rede.

Por exemplo, usando nossa topologia:

7d6654c2e4907f2a.png

Vamos ver quais namespaces Happy criou para isso:

$ ip netns list
happy004
happy003
happy002
happy001
happy000

Se você verificar a seção netns do arquivo JSON Happy state, poderá ver a quais nós e redes cada namespace corresponde:

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

49cfdce6ff9dd745.png

Registros de tempo de execução

Os comandos emitidos para os nós são comandos básicos de terminal executados de dentro do namespace de cada nó. Uma maneira fácil de ver isso é habilitar os logs de tempo de execução feliz.

Abra uma segunda janela de terminal e ative os registros, eles serão executados continuamente nesta janela:

$ happy-state -l

Volte para a primeira janela e execute um Happy ping:

$ happy-ping 01ThreadNode 02BorderRouter

Verifique as entradas de log mais recentes na segunda janela do terminal. Você deve ver uma linha como esta nos registros:

DEBUG [Driver:CallCmd():416] Happy [happy]: > sudo ip netns exec happy000 ping6 -c 1 2001:0db8:0001:0002:5e53:bbff:fe05:484b

O happy-ping comando é nada mais do que feliz que funciona a ping6 comando no happy000 namespace ( 01ThreadNode ).

Insira um nó

Use happy-shell para executar comandos não Happy como se estivesse conectado a um dos nós (namespaces de rede):

$ happy-shell 01ThreadNode
root@01ThreadNode:#

Dispositivos simulados são executados dentro de cada namespace, e eles só têm acesso à configuração de rede especificada por meio de Happy.

Verifique a configuração da interface para o nó. Isso será diferente da configuração de todo o sistema operacional e deve refletir o que está listado no 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 sair do namespace do nó:

root@01ThreadNode:# exit

Com uma compreensão de como Happy usa namespaces de rede Linux, você agora pode perceber que é possível conectar uma rede Happy simulada à Internet e acessar endereços públicos de dentro de nós simulados. Isso é útil para conectar seus dispositivos simulados a um serviço real (como o Nest Service over Weave).

O serviço em Weave é uma infraestrutura baseada em nuvem que conecta nós HAN em um modelo de dados, fornece acesso remoto e implementa controladores inteligentes para criar um ecossistema abrangente.

O serviço pode ser representado de duas maneiras principais com Happy:

  • Como um serviço simulado em seu próprio namespace de rede (Happy node)
  • Como um verdadeiro serviço em nuvem na internet

Topologias predefinidas foram fornecidas em ~/happy/topologies como um exemplo de cada cenário de serviço.

Serviço simulado em um nó feliz

Remova todas as topologias Happy existentes:

$ happy-state-delete

Confirme um estado vazio com os comandos happy-state e weave-state .

Carregue uma topologia predefinida com ponto de acesso (AP) e nós de serviço:

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

6d04cbfcc84038e2.png

Verifique os estados Happy e Weave para confirmar a topologia. Nessa topologia, onhub é o AP, enquanto a cloud é o serviço simulado. Observe que ambos estão conectados a uma rede de Internet do 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 trama

Um túnel Weave conecta o tecido Weave a um serviço. Esta é uma rota segura que transfere mensagens UDP IPv6 entre o HAN e o serviço. Nesta topologia, o nó BorderRouter é o gateway da rede Weave, que funciona como o ponto final do túnel no HAN.

Crie o túnel Weave:

$ weave-tunnel-start BorderRouter cloud

Verifique novamente o estado Feliz. Você deve ver uma nova interface de túnel com um endereço Weave IPv6 no nó da 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

Agora você pode executar ping com êxito entre os nós na malha Weave e o prefixo global Weave do serviço:

$ happy-ping ThreadNode cloud
[Ping] ping from ThreadNode to cloud on address
    fd00:0000:fab1:0005:1ab4:3002:0000:0011 -> 0% packet loss

Serviço de nuvem real na internet

Remova todas as topologias Happy existentes:

$ happy-state-delete

Confirme um estado vazio com os comandos happy-state e weave-state .

Carregue uma topologia predefinida com um nó de ponto de acesso (AP):

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

c75127417ef3833a.png

Nesta topologia, onhub é o AP. Verifique o estado de Feliz. É semelhante à topologia anterior, sem a rede de Internet e o nó de 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

Como cada nó Happy é um namespace de rede, eles são particionados da Internet pública por padrão. Teste isso inserindo um nó Happy e executando o ping em um endereço público da Internet. Usaremos 8.8.8.8 , um dos endereços IPv4 do google.com.

$ happy-shell onhub
root@onhub:# ping -c2 8.8.8.8
connect: Network is unreachable

Para conectar o nó onhub à Internet, ele deve ser conectado a essa interface na configuração do sistema operacional Linux.

Saia do nó:

root@onhub:# exit

Determine a interface para sua conexão de Internet com o 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

Encontre a rota default . Esta é a conexão com a Internet para sua máquina Linux. A coluna Iface indica qual interface está sendo usada para essa conectividade. No exemplo acima, é em1 .

Use a happy-internet para configurar a ponte, usando a interface para sua rota padrão. Para o sinalizador --isp , use o nome da interface sem números à direita. Neste exemplo, são em . Se sua interface padrão for eth1 , o sinalizador --isp seria eth .

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

Não haverá nenhuma mudança visível na saída de happy-state , mas o nó onhub deve ter conectividade com a Internet. Vamos voltar ao nó e verificar:

$ 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

Sucesso!

c4d411ab1734131.png

DNS

Nós felizes não têm recursos de DNS integrados. Se você tentar executar ping em google.com, ele falhará:

root@onhub:# ping -c2 google.com
ping: unknown host google.com

Felizmente, Happy oferece suporte para DNS. Saia do nó e encontre os servidores DNS para sua máquina Linux. Certifique-se de usar a interface padrão apropriada:

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

Use estes endereços DNS com happy-dns :

$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53

Agora tente onhub ping em google.com de dentro do nó 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

Saia do nó onhub quando terminar:

root@onhub:# exit

Túnel de trama

Como o serviço simulado, um túnel Weave deve ser configurado entre o HAN simulado no Happy e o serviço. Com um serviço de nuvem real, use o endereço IP ou URL do serviço na configuração do túnel. Por exemplo:

$ weave-tunnel-start BorderRouter mycloud.service.com

3ed2c3c0df67f4d2.png

É importante sempre limpar as topologias Happy quando terminar de usá-las, para evitar problemas com a configuração da rede Linux.

Se você habilitou o suporte DNS em sua topologia, remova-o executando novamente o comando com o sinalizador -d (excluir) primeiro . Isso deve ser executado antes que quaisquer nós Happy sejam removidos, para garantir que a configuração da rede seja devidamente atualizada.

$ happy-dns -d 172.16.255.1 172.16.255.153 172.16.255.53

Em seguida, exclua o estado Feliz:

$ happy-state-delete

Ocasionalmente, alguns arquivos de estado podem permanecer após uma exclusão de estado. Se você tiver problemas e Happy não estiver funcionando como esperado, exclua o estado com happy-state-delete e use os seguintes comandos para forçar qualquer limpeza restante:

$ ip netns | xargs -I {} sudo ip netns delete {}
$ rm -rf ~/.*state.json
$ rm -rf ~/.*state.json.lock

Sua máquina deve voltar à configuração de rede normal.

Agora você sabe:

  • Como usar o Happy para simular suas próprias redes de área doméstica IoT
  • Como conectar topologias Happy à internet
  • O básico do Weave via OpenWeave, a versão de código aberto do Weave da Nest

Próximos passos

Partindo deste Codelab, tente os seguintes exercícios:

  • Crie uma topologia maior com vários nós em cada Thread e rede Wi-Fi e estabeleça conectividade entre todos os nós
  • Crie um script bash para carregar a topologia via happy-state-load ou weave-state-load
  • Explore outros comandos Happy, como happy-traceroute e happy-process-*

Leitura adicional

Verifique openweave.io para uma variedade de referências, incluindo:

f6996428fb06dede.png