1. Introdução
OpenThread lançado pela Google é uma implementação open-source do Tópico protocolo de rede. O Google Nest lançou o OpenThread para tornar a tecnologia usada nos produtos Nest amplamente disponível aos desenvolvedores para acelerar o desenvolvimento de produtos para a casa conectada.
A especificação da linha define um protocolo de comunicação sem fios baseados em IPv6 fiável, segura e de baixo consumo de dispositivo para dispositivo para aplicações domésticas. O OpenThread implementa todas as camadas de rede Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, Mesh Link Establishment e Mesh Routing.
Este Codelab orientará você na simulação de uma rede Thread em dispositivos emulados usando o Docker.
O que você vai aprender
- Como configurar a cadeia de ferramentas de compilação OpenThread
- Como simular uma rede Thread
- Como autenticar nós de thread
- Como gerenciar uma rede Thread com OpenThread Daemon
O que você precisará
- Janela de encaixe
- Conhecimento básico de Linux, roteamento de rede
2. Configure o Docker
Este Codelab foi projetado para usar o Docker em uma máquina Linux, Mac OS X ou Windows. Linux é o ambiente recomendado.
Instalar o Docker
Instale o Docker no sistema operacional de sua escolha.
Puxe a imagem do Docker
Uma vez Docker está instalado, abra uma janela de terminal e puxe a openthread/codelab_otsim imagem Docker. Esta imagem apresenta OpenThread e OpenThread Daemon pré-construídos e prontos para uso neste Codelab.
$ docker pull openthread/codelab_otsim:latest
Observe que pode levar alguns minutos para baixar completamente.
Em uma janela de terminal, iniciar um recipiente Docker a partir da imagem e conectar-se a sua bash shell:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
Observe os sinalizadores, que são necessários para este Codelab:
-
--sysctl net.ipv6.conf.all.disable_ipv6=0- isso permite IPv6 dentro do recipiente -
--cap-add=net_admin- permite a capacidade NET_ADMIN, que permite que você execute operações de rede relacionadas, tais como adicionar rotas IP
Uma vez no contêiner, você deve ter um prompt semelhante a este:
root@c0f3912a74ff:/#
No exemplo acima, o c0f3912a74ff é a ID do contentor. O ID do contêiner para sua instância do contêiner do Docker será diferente daquele mostrado nos prompts deste Codelab.
Usando o Docker
Este Codelab pressupõe que você conheça os fundamentos do uso do Docker. Você deve permanecer no contêiner do Docker durante todo o Codelab.
3. Simule uma rede Thread
O aplicativo de exemplo que você usará para este Codelab demonstra um aplicativo OpenThread mínimo que expõe a configuração do OpenThread e as interfaces de gerenciamento por meio de uma interface de linha de comando (CLI) básica.
Este exercício orienta você pelas etapas mínimas necessárias para executar ping em um dispositivo Thread emulado de outro dispositivo Thread emulado.
A figura abaixo descreve uma topologia de rede Thread básica. Para este exercício, vamos emular os dois nós dentro do círculo verde: um Thread Leader e Thread Router com uma única conexão entre eles.
Crie a rede
1. Iniciar o Nó 1
Se você não tiver feito isso, em uma janela de terminal, iniciar o recipiente Docker e conectar-se a sua bash shell:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
No recipiente Docker, navegue até o openthread diretório e gerar o processo CLI para um dispositivo Tópico emulado usando o ot-cli-ftd binário.
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Nota: Se você não vê a > alerta depois de executar este comando, prima enter .
Este binário implementa um dispositivo OpenThread emulado em cima do POSIX. O driver de rádio IEEE 802.15.4 é implementado em cima do UDP (os quadros IEEE 802.15.4 são passados dentro de cargas UDP).
O argumento de 1 é um descritor de arquivo que representa os bits menos significativos da "fábrica-designado" IEEE EUI-64 para o dispositivo emulado. Esse valor também é usado ao vincular a uma porta UDP para emulação de rádio IEEE 802.15.4 (porta = 9000 + descritor de arquivo). Cada instância de um dispositivo Thread emulado neste Codelab usará um descritor de arquivo diferente.
Nota: Apenas descritores de arquivos utilização de 1 ou maior conforme observado neste Codelab quando desova o processo para um dispositivo emulado. Um descritor de arquivo 0 é reservada para outro uso.
Crie um novo Conjunto de Dados Operacionais e confirme-o como ativo. O Conjunto de Dados Operacional é a configuração da rede Thread que você está criando.
> dataset init new Done > dataset Active Timestamp: 1 Channel: 20 Channel Mask: 07fff800 Ext PAN ID: d6263b6d857647da Mesh Local Prefix: fd61:2344:9a52:ede0/64 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Confirme este conjunto de dados como ativo:
> dataset commit active Done
Abra a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
Aguarde alguns segundos e verifique se o dispositivo se tornou o Thread Leader. O Líder é o dispositivo responsável por gerenciar a atribuição de ID do roteador.
> state leader Done
Veja os endereços IPv6 atribuídos à interface Thread do Node 1 (sua saída será diferente):
> ipaddr fd61:2344:9a52:ede0:0:ff:fe00:fc00 fd61:2344:9a52:ede0:0:ff:fe00:5000 fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 fe80:0:0:0:94da:92ea:1353:4f3b Done
Observe os tipos de endereço IPv6 específicos:
- Começa com
fd= malha-locais - Começa com
fe80= link-local
Os tipos de endereços locais de malha são classificados ainda mais:
- Contém
ff:fe00= Router Locator (RLOC) - Não contém
ff:fe00= Endpoint Identifier (EID)
Identifique o EID na saída do console e anote-o para uso posterior. Na saída de exemplo acima, o EID é:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Inicie o Nó 2
Abra um novo terminal e executar uma bash shell no recipiente Docker atualmente em execução a ser usado para o nó 2.
$ docker exec -it codelab_otsim_ctnr bash
Neste novo bash pronta, navegue até o openthread diretório e gerar o processo CLI. Este é o seu segundo dispositivo Thread emulado:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2
Nota: Se você não vê a > alerta depois de executar este comando, prima enter .
Configure a chave de rede do thread e o ID do PAN, usando os mesmos valores do conjunto de dados operacional do nó 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Confirme este conjunto de dados como ativo:
> dataset commit active Done
Abra a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
O dispositivo irá inicializar-se como um filho. Um Thread Child é equivalente a um End Device, que é um Thread device que transmite e recebe tráfego unicast apenas com um dispositivo Parent.
> state child Done
Dentro de 2 minutos, você deve ver o detector de estado da child ao router . Um Thread Router é capaz de rotear o tráfego entre os dispositivos Thread. Também é conhecido como Pai.
> state router Done
Verifique a rede
Uma maneira fácil de verificar a rede mesh é observar a tabela de roteadores.
1. Verifique a conectividade
No nó 2, obtenha o RLOC16. O RLOC16 são os últimos 16 bits do endereço RLOC IPv6 do dispositivo.
> rloc16 5800 Done
No Nó 1, verifique a tabela de roteadores para o RLOC16 do Nó 2. Certifique-se de que o Nó 2 mudou primeiro para o estado do roteador.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+--------+-------+---+--------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
RLOC de nó 2 0x5800 é encontrada na tabela, o que confirma que ele é ligado para a malha.
2. Ping o Nó 1 do Nó 2
Verifique a conectividade entre os dois dispositivos Thread emulados. No nó 2, ping a EID atribuído ao nó 1:
> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 > 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms
Imprensa enter para voltar ao > alerta CLI.
Teste a rede
Agora que você pode executar ping entre dois dispositivos Thread emulados, teste a rede mesh colocando um nó offline.
Retorne ao Nó 1 e pare o Thread:
> thread stop Done
Mude para o Nó 2 e verifique o estado. Dentro de dois minutos, Node 2 detecta que o líder (nó 1) é desligada, e você deve ver Nó 2 transição para ser o leader da rede:
> state router Done ... > state leader Done
Uma vez confirmada, parada da linha e reset de fábrica nó 2 antes de sair de volta para o Docker bash pronta. Uma redefinição de fábrica é feita para garantir que as credenciais da rede Thread que usamos neste exercício não sejam transferidas para o próximo exercício.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Você pode ter que pressionar enter algumas vezes para trazer a > volta rápida após um factoryreset comando. Não saia do contêiner do Docker.
Também redefinir as configurações de fábrica e sair do nó 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Veja a OpenThread CLI Referência para explorar todos os comandos da CLI disponíveis.
4. Autenticar nós com comissionamento
No exercício anterior, você configurou uma rede Thread com dois dispositivos simulados e conectividade verificada. No entanto, isso só permite que o tráfego local de link IPv6 não autenticado passe entre os dispositivos. Para rotear o tráfego IPv6 global entre eles (e a Internet por meio de um roteador de borda de thread), os nós devem ser autenticados.
Para autenticar, um dispositivo deve atuar como Comissário. O Comissário é o servidor de autenticação atualmente eleito para novos dispositivos Thread e o autorizador para fornecer as credenciais de rede necessárias para os dispositivos ingressarem na rede.
Neste exercício, usaremos a mesma topologia de dois nós de antes. Para autenticação, o Thread Leader atuará como Comissário, o Thread Router como Joiner.
Janela de encaixe
Para cada nó (janela de terminal) nos exercícios restantes, verifique se você está executando o contêiner do Docker com a compilação OpenThread. Se continuar com o exercício anterior, você ainda deve ter duas bash prompts dentro do mesmo recipiente Docker já está aberto. Se não, veja o passo Docker solução de problemas, ou simplesmente refazer a simular um exercício rede Thread.
1. Crie uma rede
No nó 1, gere o processo CLI:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Nota: Se você não vê a > alerta depois de executar este comando, prima enter .
Crie um novo Conjunto de Dados Operacionais, confirme-o como ativo e inicie o Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 12 Channel Mask: 07fff800 Ext PAN ID: e68d05794bf13052 Mesh Local Prefix: fd7d:ddf7:877b:8756/64 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
Confirme este conjunto de dados como ativo:
> dataset commit active Done
Abra a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
Aguarde alguns segundos e verifique se o dispositivo se tornou um Thread Leader:
> state leader Done
2. Iniciar a função de Comissário
Ainda no Nó 1, inicie a função de Comissário:
> commissioner start Done
Permitir que qualquer Joiner (usando o * universal) com o J01NME Joiner Credencial a Comissão sobre a rede. Um Joiner é um dispositivo que é adicionado por um administrador humano a uma Thread Network comissionada.
> commissioner joiner add * J01NME Done
3. Inicie a função de Associado
Em uma segunda janela de terminal, no contêiner do Docker, gere um novo processo de CLI. Este é o Nó 2.
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2
No nó 2, habilite a função Joiner usando o J01NME Joiner Credencial.
> ifconfig up Done > joiner start J01NME Done
... aguarde alguns segundos para confirmação ...
Join success
Como Joiner, o dispositivo (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Rede Thread.
Agora que o Nó 2 está autenticado, inicie o Thread:
> thread start Done
4. Valide a autenticação de rede
Verifique o state no nó 2, para validar que já aderiram à rede. Dentro de dois minutos, o nó 2 a transição de child para router :
> state child Done ... > state router Done
5. Redefinir configuração
Para se preparar para o próximo exercício, redefina a configuração. Em cada nó, pare o Thread, faça uma redefinição de fábrica e saia do dispositivo Thread emulado:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Você pode ter que pressionar enter algumas vezes para trazer a > volta rápida após um factoryreset comando.
5. Gerencie a rede com o OpenThread Daemon
Para este exercício, vamos simular uma instância de CLI (um único dispositivo SoC Thread incorporado) e uma instância de Radio Co-Processor (RCP).
ot-daemon é um modo do aplicativo OpenThread Posix que usa um soquete de UNIX como entrada e saída, de modo que OpenThread núcleo pode funcionar como um serviço. Um cliente pode se comunicar com este serviço conectando-se ao soquete usando o OpenThread CLI como protocolo.
ot-ctl é um CLI fornecida pelo ot-daemon para gerenciar e configurar o RCP. Usando isso, vamos conectar o RCP à rede criada pelo dispositivo Thread.
Janela de encaixe
Para cada nó (janela de terminal) neste exercício, verifique se você está executando o contêiner do Docker com a compilação OpenThread. Se continuar com o exercício anterior, você deve ter dois bash prompts dentro do mesmo recipiente Docker já está aberto. Se não, veja o passo Docker Solução de problemas.
Usar ot-daemon
Este exercício usará três janelas de terminal, correspondentes ao seguinte:
- Instância CLI do dispositivo Thread simulado (Nó 1)
-
ot-daemonprocesso -
ot-ctlexemplo CLI
1. Iniciar o Nó 1
Na primeira janela do terminal, gere o processo CLI para seu dispositivo Thread emulado:
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1
Nota: Se você não vê a > alerta depois de executar este comando, prima enter .
Crie um novo Conjunto de Dados Operacionais, confirme-o como ativo e inicie o Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 13 Channel Mask: 07fff800 Ext PAN ID: 97d584bcd493b824 Mesh Local Prefix: fd55:cf34:dea5:7994/64 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
Confirme este conjunto de dados como ativo:
> dataset commit active Done
Abra a interface IPv6:
> ifconfig up Done
Inicie a operação do protocolo Thread:
> thread start Done
Veja os endereços IPv6 atribuídos à interface Thread do Node 1:
> ipaddr fd55:cf34:dea5:7994:0:ff:fe00:fc00 fd55:cf34:dea5:7994:0:ff:fe00:d000 fd55:cf34:dea5:7994:460:872c:e807:c4ab fe80:0:0:0:9cd8:aab6:482f:4cdc Done >
Como explicado na Simular um passo rede Thread, um endereço é link-local ( fe80 ) e três são de malha-local ( fd ). A EID é o endereço malha-local que não contenha ff:fe00 no endereço. Nessa saída de exemplo, a EID é fd55:cf34:dea5:7994:460:872c:e807:c4ab .
Identificar o EID específico de sua ipaddr saída, que será usado para se comunicar com o nó.
2. Inicie ot-daemon
Na segunda janela de terminal, criar um tun nó de dispositivo e definir permissões de leitura / gravação:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
Este dispositivo é usado para transmissão e recebimento de pacotes em dispositivos virtuais. Você pode receber um erro se o dispositivo já tiver sido criado - isso é normal e pode ser ignorado.
Navegue até a openthread diretório, e começar a ot-daemon para um nó de RCP, que chamaremos Nó 2. Use o -v detalhado bandeira para que você possa ver a saída log e confirme que ele está sendo executado:
root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-daemon -v \
'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'
Quando for bem sucedida, ot-daemon no modo detalhado gera uma saída semelhante à que se segue:
ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun 7 2020 18:05:15 ot-daemon[228024]: Thread version: 2 ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun 7 2020 18:06:08
Deixe este terminal aberto e rodando em segundo plano. Você não digitará mais nenhum comando nele.
3. Use ot-ctl para entrar na rede
Nós não ter encomendado Nó 2 (o ot-daemon RCP) a qualquer rede Tópico ainda. Este é o lugar onde ot-ctl entra. ot-ctl usa o mesmo CLI como o aplicativo OpenThread CLI. Portanto, você pode controlar ot-daemon nós da mesma forma como os outros dispositivos de Tópicos simulados.
Abra uma terceira janela de terminal e execute o container existente:
$ docker exec -it codelab_otsim_ctnr bash
Uma vez no recipiente, iniciar ot-ctl :
root@c0f3912a74ff:/# cd ~/src/openthread root@c0f3912a74ff:/# ./output/posix/bin/ot-ctl >
Você vai usar ot-ctl nesta terceira janela de terminal para gerenciar o nó 2 (o nó RCP) que começou na segunda janela do terminal com ot-daemon . Verifique o state do nó 2:
> state disabled Done
Obter do Nó 2 eui64 , para restringir juntando para o específico Joiner:
> eui64 18b4300000000001 Done
No Node 1 (primeira janela do terminal), inicie o Commissioner e restrinja a adesão apenas ao eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Na terceira janela do terminal, abra a interface de rede para o Nó 2 e entre na rede:
> ifconfig up Done > joiner start J01NME Done
... aguarde alguns segundos para confirmação ...
Join success
Como Joiner, o RCP (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Rede Thread.
Agora junte o Nó 2 à rede Thread (novamente, na terceira janela do terminal):
> thread start Done
4. Valide a autenticação de rede
No terceiro terminal, verificar o state no nó 2, para validar que já aderiram à rede. Dentro de dois minutos, o nó 2 a transição de child para router :
> state child Done ... > state router Done
5. Valide a conectividade
Na terceira janela de terminal, pressione Ctrl + D para parar ot-ctl e voltar para o contêiner bash console. A partir deste console, pingue Nó 1, usando seu EID com a ping6 comando. Se o ot-daemon exemplo RCP se une com sucesso para e se comunicar com a rede Thread, o ping tiver êxito:
root@c0f3912a74ff:/# ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms --- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms
6. Solução de problemas do Docker
Se você saiu do contêiner do Docker
bash prompts, você pode precisar verificar se ele está funcionando e reiniciar / reenter conforme necessário.
Para mostrar quais contêineres do Docker estão em execução:
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 codelab_otsim "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Para mostrar todos os contêineres do Docker (em execução e parados):
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 codelab_otsim "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Se você não vê recipiente codelab_otsim_ctnr na saída de qualquer docker ps de comando, executá-lo novamente:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/codelab_otsim bash
Se o recipiente estiver parado (listado na docker ps -a , mas não docker ps ), reinicie-o:
$ docker start -i codelab_otsim_ctnr
Se o recipiente de encaixe já está em execução (listado em docker ps ), voltar a ligar para o recipiente em cada terminal:
$ docker exec -it codelab_otsim_ctnr bash
Erros "Operação não permitida"
Se você tiver Operation not permitted erros ao criar novos nós OpenThread (usando o mknod comando), certifique-se você estiver executando Docker como usuário root acordo com os comandos fornecidos neste Codelab. Que isso Codelab não suporta a execução Docker em modo sem raízes .
7. Parabéns!
Você simulou com sucesso sua primeira rede Thread usando OpenThread. Impressionante!
Neste Codelab você aprendeu como:
- Iniciar e gerenciar o contêiner do OpenThread Simulation Docker
- Simular uma rede Thread
- Autenticar nós de thread
- Gerenciar uma rede Thread com OpenThread Daemon
Para saber mais sobre Thread e OpenThread, explore estas referências:
- Thread Primer em openthread.io
- Especificação da rosca
- Repositório OpenThread GitHub
- Referência de CLI do OpenThread
- Suporte adicional ao OpenThread Docker
Ou, tente usar OpenThread Border Router em um recipiente Docker !