1. Introdução
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 domésticas de 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.
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
2. Comece
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
3. Sua primeira topologia
Vamos criar a seguinte topologia de três nós com Happy.
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:
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:
4. Teste a conectividade
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:
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,
02BorderRouterpara 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 |
| | |
| | |
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.
Para permitir uma maneira mais segura e confiável de conectar tudo, vamos adicionar Weave na parte superior do HAN.
5. Adicionar Trama
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 serviço Nest 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:
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.
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 do Weave usam esses endereços para se comunicarem na malha do 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.
6. Manutenção da topologia
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, tanto no shell-script quanto no formato 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 .
7. Como funciona
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:
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",
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
8. Conecte-se a um serviço
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
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
Agora você pode executar ping com êxito entre os nós na estrutura 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
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!
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
9. Limpando
É 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.
10. Parabéns!
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 a conectividade entre todos os nós
- Criar um script para carregar a topologia via
happy-state-loadouweave-state-load - Explorar outros comandos felizes, como
happy-tracerouteehappy-process-*
Leitura adicional
Verifique openweave.io para uma variedade de referências, incluindo: