O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Primeiros passos com Happy e Weave

Feliz é uma ferramenta criada por laboratórios ninho 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:

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

Neste Codelab, você vai aprender como começar com feliz, bem como as noções básicas de Weave para dispositivos da Internet das coisas. A implementação Weave você vai usar é OpenWeave , uma versão de código aberto lançado 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 feliz

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

$ cd ~/happy
$ make

Verifique a 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 a Happy onde encontrar a instalação do Weave. Atualizar a configuração feliz com o caminho para /src/test-apps dentro de sua construçã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 seu PATH variável de ambiente com o caminho utilizado para binários felizes:

$ 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. Este 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 felicidade:

$ 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

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

Verifique o estado 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 criar 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 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 a nossa rede feliz é instalado e funcionando, vamos testar sua conectividade através de ping os 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

Os happy-ping tentativas de comando para executar ping cada endereço IP para cada interface 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 falhou porque o encaminhamento não foi habilitado entre wpan0 e wlan0 em 02BorderRouter . Assim, 01ThreadNode não tem idéia 03WiFiNode existe, ou como alcançá-la. 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:

  • a rede mais próxima porta de entrada, 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

Isto pode ser feito individualmente para cada nó com happy-node-route , mas é mais fácil de fazê-lo 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 uma explicação sobre os sinalizadores de linha de comando, use happy-network-route -h .

A happy-network-route comando também gira sobre IPv4 e IPv6 de encaminhamento 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 em diante, ele sabe como chegar a wlan0 interface. O ping IPv4 ainda falha, porque configuramos apenas as rotas e encaminhamento IPv6 (também porque o Thread não roda em IPv4).

Como adicionamos rotas de rede em 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.

O 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 Nest Service e quaisquer dispositivos móveis que participam do HAN. Ele fica no topo do HAN e permite um roteamento mais fácil entre as diferentes tecnologias de link de rede subjacentes (por exemplo, Thread ou Wi-Fi).

Criar o tecido Weave para o seu HAN, usando fab1 como o Fabric ID, em seguida, configurar 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 tecer, e cada interface tem um novo endereço IPv6 começando com fd00 . Para obter mais informações sobre o tecido Weave, utilize a weave-state comando:

$ weave-state

State Name: weave

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

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

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

ce3fa9082408355b.png

Tecido de trama

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

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

Usos tecer 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. Combinando isso com a ID do Fabric gera o prefixo global Weave 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 juntador" 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, 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

Note que existem quatro novos endereços IPv6 na topologia feliz, todos começando com a nossa Weave global Prefixo 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 à happy-network-route comando 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

Isto coloca um arquivo JSON com a topologia completa na raiz do seu ~/ pasta. O arquivo JSON é uma cópia de seu atual estado feliz, que é 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 relacionados encontrados no ~/.happy-state.json arquivo. Verifique happy-state e weave-state para confirmar uma configuração vazio:

$ 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 plug-in Weave
  • weave-state-load - suporta plugins Weave

Então, se a sua topologia inclui Weave, use sempre a weave-state-load de comando para que seja aplicado o tecido Weave e configuração associada.

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. Encontrá-los em ~/happy/topologies .

O OpenWeave também vem com topologias Happy predefinidas selecionadas para fins de teste. Encontrá-los 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 particionar 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 o netns seção do arquivo JSON estado feliz, você pode ver o que nós e redes cada um corresponde namespace para:

$ 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-Boas como se registrado em um dos nós (namespaces 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 deixar namespace do nó:

root@01ThreadNode:# exit

Com uma compreensão de como Happy usa namespaces de rede Linux, você pode agora 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 pré-definidos foram fornecidos em ~/happy/topologies como um exemplo de cada cenário serviço.

Serviço simulado em um nó feliz

Remova todas as topologias Happy existentes:

$ happy-state-delete

Confirmar um estado vazio com as happy-state e weave-state comandos.

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. Nesta topologia, onhub é a AP, enquanto cloud é o serviço simulado. Nota ambos estão conectados a uma Internet rede 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 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 BorderRouter nó é o gateway de rede Weave, que funciona como o ponto final do túnel sobre o HAN.

Crie o túnel Weave:

$ weave-tunnel-start BorderRouter cloud

Verifique novamente o estado Feliz. Você deverá ver uma nova interface de túnel com um endereço IPv6 Weave na cloud nó:

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 no tecido do Weave e o prefixo global do 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

Confirmar um estado vazio com as happy-state e weave-state comandos.

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

$ 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. Vamos usar 8.8.8.8 , um dos do google.com endereços IPv4.

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

Para conectar o onhub nó à internet, deve ser superada para que a interface com a configuração de nível de sistema operacional Linux.

Saia do nó:

root@onhub:# exit

Determinar a interface para sua conexão de internet com a route de comando:

$ route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         192.168.1.0     0.0.0.0         UG    0      0        0 em1

Encontre o default de rota. Esta é a conexão com a Internet para sua máquina Linux. O Iface coluna indica a interface que está a ser utilizado para que a conectividade. No exemplo acima, é em1 .

Use happy-internet para configurar a ponte, usando a interface para a sua rota padrão. Para o --isp bandeira, utilizar o nome de interface sem fuga números. Neste exemplo, é em . Se sua interface padrão é eth1 , o --isp bandeira seria eth .

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

Não haverá nenhuma mudança visível no happy-state de saída, mas o onhub nó deve ter conectividade de 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 esses endereços DNS com happy-dns :

$ happy-dns 172.16.255.1 172.16.255.153 172.16.255.53

Agora tente ping google.com de dentro do onhub nó:

$ 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 da onhub nó quando estiver pronto:

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 de rede do Linux.

Se você ativou o suporte DNS em sua topologia, removê-lo executando novamente o comando com o -d bandeira (Apagar) em primeiro lugar. Isso deve ser executado antes que quaisquer nós Happy sejam removidos, para garantir que a configuração de 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 feliz não está funcionando como esperado, excluir o estado com happy-state-delete e, em seguida, use os seguintes comandos para forçar qualquer restante até limpo:

$ 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
  • Os princípios básicos 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
  • Criar um script para carregar a topologia via happy-state-load ou weave-state-load
  • Explorar outros comandos felizes, como happy-traceroute e happy-process-*

Leitura adicional

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

f6996428fb06dede.png