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

Simular uma rede Thread usando OpenThread no Docker

26b7f4f6b3ea0700.png

OpenThread lançado pelo Google é uma implementação de código aberto do protocolo de rede Thread . 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 casas conectadas.

A especificação Thread define um protocolo de comunicação de dispositivo a dispositivo sem fio confiável, seguro e de baixo consumo de energia baseado em IPv6 para aplicativos domésticos. 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 irá guiá-lo através da simulação de uma rede Thread em dispositivos emulados usando Docker.

O que você aprenderá

  • Como configurar o conjunto de ferramentas de construçã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á

  • Docker
  • Conhecimento básico de Linux, roteamento de rede

Este Codelab foi projetado para usar o Docker em uma máquina Linux, Mac OS X ou Windows. Linux é o ambiente recomendado.

Instale o Docker

Instale o Docker no sistema operacional de sua escolha.

Baixe o Docker

Extraia a imagem Docker

Depois que o Docker estiver instalado, abra uma janela de terminal e extraia a imagem openthread/codelab_otsim Docker. Esta imagem apresenta o OpenThread e o OpenThread Daemon pré-compilados e prontos para uso neste Codelab.

$ docker pull openthread/codelab_otsim:latest

Observe que o download completo pode demorar alguns minutos.

Em uma janela de terminal, inicie um contêiner do Docker a partir da imagem e conecte-se ao shell bash :

$ 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 - ativa o IPv6 dentro do contêiner
  • --cap-add=net_admin - ativa o recurso NET_ADMIN, que permite a você executar operações relacionadas à rede, como adicionar rotas IP

Uma vez no contêiner, você deverá receber um prompt semelhante a este:

root@c0f3912a74ff:/#

No exemplo acima, o c0f3912a74ff é o ID do contêiner. O ID do contêiner para sua instância do contêiner Docker será diferente daquele mostrado nos prompts para este Codelab.

Usando 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.

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 básica (CLI).

Este exercício o conduz 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 básica de rede Thread. Para este exercício, emularemos os dois nós dentro do círculo verde: um Thread Leader e Thread Router com uma única conexão entre eles.

6e3aa07675f902dc.png

Crie a rede

1. Iniciar o Nó 1

Se você ainda não fez isso, em uma janela de terminal, inicie o contêiner do Docker e conecte-se ao shell bash :

$ 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 contêiner do Docker, navegue até o diretório openthread e gere o processo CLI para um dispositivo Thread emulado usando o binário ot-cli-ftd .

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Este binário implementa um dispositivo OpenThread emulado no topo do POSIX. O driver de rádio IEEE 802.15.4 é implementado na parte superior do UDP (os quadros IEEE 802.15.4 são passados ​​dentro de cargas úteis UDP).

O argumento de 1 é um descritor de arquivo que representa os bits menos significativos do IEEE EUI-64 "atribuído de fábrica" ​​para o dispositivo emulado. Este 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: Use apenas descritores de arquivo de 1 ou maior, conforme observado neste Codelab, ao gerar o processo para um dispositivo emulado. Um descritor de arquivo de 0 é reservado para outro uso.

Se você não vê o

>

prompt após executar este comando, pressione

enter

.

Crie um novo Dataset Operacional e confirme-o como ativo. O conjunto de dados operacionais é 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
Master 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 da ID do roteador.

> state
leader
Done

Visualize os endereços IPv6 atribuídos à interface Thread do Nó 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 = mesh-local
  • Começa com fe80 = link-local

Os tipos de endereço local de malha são classificados ainda:

  • Contém ff:fe00 = Router Locator (RLOC)
  • Não contém ff:fe00 = Endpoint Identifier (EID)

Identifique o EID na saída do console, anote-o para uso posterior. No exemplo de saída acima, o EID é:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. Iniciar o Nó 2

Abra um novo terminal e execute um shell bash no contêiner do Docker em execução para usar no Nó 2.

$ docker exec -it codelab_otsim_ctnr bash

Nesse novo prompt do bash , navegue até o diretório openthread e openthread o processo CLI. Este é o seu segundo dispositivo Thread emulado:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

Se você não vê o

>

prompt após executar este comando, pressione

enter

.

Configure a Thread Master Key e o PAN ID, usando os mesmos valores do Conjunto de Dados Operacionais do Nó 1:

> dataset masterkey 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 se inicializará como Criança. Um Thread Child é equivalente a um End Device, que é um dispositivo Thread que transmite e recebe tráfego unicast apenas com um dispositivo Parent.

> state
child
Done

Em 2 minutos, você deverá ver a mudança de estado de child para router . Um Thread Router é capaz de rotear o tráfego entre dispositivos Thread. Também é conhecido como Pai.

> state
router
Done

Verifique a rede

Uma maneira fácil de verificar a rede mesh é examinar a tabela do roteador.

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 do roteador para RLOC16 do Nó 2. Certifique-se de que o Nó 2 tenha mudado para o estado de roteador primeiro.

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

O RLOC do nó 2 de 0x5800 é encontrado na tabela, confirmando que ele está conectado à malha.

2. Faça ping no nó 1 do nó 2

Verifique a conectividade entre os dois dispositivos Thread emulados. No Nó 2, ping no 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

Pressione enter para retornar ao > prompt CLI.

Teste a rede

Agora que você pode executar ping com êxito entre dois dispositivos Thread emulados, teste a rede mesh colocando um nó offline.

Retorne ao Nó 1 e pare o Tópico:

> thread stop
Done

Mude para o Nó 2 e verifique o estado. Em dois minutos, o Nó 2 detecta que o líder (Nó 1) está offline e você deve ver a transição do Nó 2 para ser o leader da rede:

> state
router
Done
...
> state
leader
Done

Depois de confirmado, pare o Thread e redefina o Nó 2 de fábrica antes de sair de volta para o prompt do bash do Docker. Uma redefinição de fábrica é feita para garantir que as credenciais de rede Thread que usamos neste exercício não sejam transportadas para o próximo exercício.

> thread stop
Done
> factoryreset
>
> exit
root@c0f3912a74ff:/#

Pode ser necessário pressionar enter algumas vezes para trazer o prompt > volta após um comando de factoryreset . 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:/#

Consulte OpenThread CLI Reference para explorar todos os comandos CLI disponíveis.

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 de link local 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 um 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 agirá como o Comissário, o Thread Router como Joiner.

d6a67e8a0d0b5dcb.png

Docker

Para cada Nó (janela de terminal) nos exercícios restantes, certifique-se de estar executando o contêiner do Docker com a construção OpenThread. Se continuar do exercício anterior, você ainda deve ter dois prompts bash no mesmo contêiner do Docker já abertos. Caso contrário, consulte a etapa de solução de problemas do Docker ou simplesmente refaça o exercício de rede Simulate a 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

Se você não vê o

>

prompt após executar este comando, pressione

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
Master 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. Comece a função de Comissário

Ainda no Nó 1, comece a função de Comissário:

> commissioner start
Done

Permita que qualquer Joiner (usando o caractere curinga * ) com a Credencial de Joiner J01NME comissão na rede. Um Joiner é um dispositivo adicionado por um administrador humano a uma Thread Network comissionada.

> commissioner joiner add * J01NME
Done

3. Inicie a função de Joiner

Em uma segunda janela de terminal, no contêiner do Docker, gere um novo processo CLI. Este é o Nó 2.

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

No Nó 2, ative a função de Joiner usando a Credencial de Joiner J01NME .

> ifconfig up
Done
> joiner start J01NME
Done

... aguarde alguns segundos pela confirmação ...

Join success

Como um Joiner, o dispositivo (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Thread Network.

Agora que o Nó 2 está autenticado, inicie o Thread:

> thread start
Done

4. Valide a autenticação da rede

Verifique o state no Nó 2 para validar se ele agora está conectado à rede. Em dois minutos, o Nó 2 faz a transição do child para o 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:/#

Pode ser necessário pressionar enter algumas vezes para trazer o prompt > volta após um comando de factoryreset .

Para este exercício, vamos simular uma instância CLI (um único dispositivo SoC Thread integrado) e uma instância Radio Co-Processor (RCP).

ot-daemon é um modo do aplicativo OpenThread Posix que usa um soquete UNIX como entrada e saída, para que o núcleo do OpenThread possa ser executado como um serviço. Um cliente pode se comunicar com este serviço conectando-se ao soquete usando a CLI OpenThread como protocolo.

ot-ctl é uma CLI fornecida pelo ot-daemon para gerenciar e configurar o RCP. Usando isso, conectaremos o RCP à rede criada pelo dispositivo Thread.

Docker

Para cada Nó (janela de terminal) neste exercício, certifique-se de estar executando o contêiner Docker com a construção OpenThread. Se continuar do exercício anterior, você deve ter dois prompts bash no mesmo contêiner do Docker já abertos. Caso contrário, consulte a etapa de solução de problemas do Docker .

Use ot-daemon

Este exercício usará três janelas de terminal, correspondendo ao seguinte:

  1. Instância CLI do dispositivo Thread simulado (Nó 1)
  2. processo ot-daemon
  3. instância CLI ot-ctl

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

Se você não vê o

>

prompt após executar este comando, pressione

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
Master 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

Visualize os endereços IPv6 atribuídos à interface Thread do Nó 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
>

Conforme explicado na etapa Simulate a Thread network , um endereço é link-local ( fe80 ) e três são mesh-local ( fd ). O EID é o endereço de malha local que não contém ff:fe00 no endereço. Neste exemplo de saída, o EID é fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identifique o EID específico de sua saída ipaddr , que será usado para se comunicar com o nó.

2. Inicie o ot-daemon

Na segunda janela do terminal, crie um nó do dispositivo tun e defina as 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 recepção de pacotes em dispositivos virtuais. Você pode obter um erro se o dispositivo já tiver sido criado - isso é normal e pode ser ignorado.

Navegue até o diretório openthread e inicie ot-daemon para um nó RCP, que chamaremos de Nó 2. Use o sinalizador -v verbose para que você possa ver a saída do log e confirmar que está em execução:

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 bem ot-daemon sucedido, ot-daemon no modo detalhado gera uma saída semelhante a esta:

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

3. Use ot-ctl para entrar na rede

Ainda não comissionamos o Nó 2 (o RCP ot-daemon ) para nenhuma rede Thread. É aqui que entra ot-ctl . ot-ctl usa a mesma CLI que o aplicativo CLI OpenThread. Portanto, você pode controlar ot-daemon nós ot-daemon da mesma maneira que os outros dispositivos Thread simulados.

Abra uma terceira janela de terminal e execute o contêiner existente:

$ docker exec -it codelab_otsim_ctnr bash

Uma vez no contêiner, inicie ot-ctl :

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-ctl
>

Verifique o state do Nó 2 (o nó RCP) que você iniciou com ot-daemon :

> state
disabled
Done

Obtenha eui64 do Nó 2, para restringir a junção ao Joiner específico:

> eui64
18b4300000000001
Done

No Nó 1, inicie o Comissário e restrinja a junção apenas a esse eui64:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

No Nó 2, abra a interface de rede e conecte-se à rede:

> ifconfig up
Done
> joiner start J01NME
Done

... aguarde alguns segundos pela confirmação ...

Join success

Como um Joiner, o RCP (Nó 2) autenticou-se com sucesso com o Comissário (Nó 1) e recebeu as credenciais da Thread Network.

Agora junte o Nó 2 à rede Thread:

> thread start
Done

4. Valide a autenticação da rede

Verifique o state no Nó 2 para validar se ele agora está conectado à rede. Em dois minutos, o Nó 2 faz a transição do child para o router :

> state
child
Done
...
> state
router
Done

5. Valide a conectividade

Saia de ot-ctl usando Ctrl + D e na linha de comando de sua máquina host, execute ping no Nó 1, usando seu EID com o comando ping6 . Se a instância ot-daemon RCP for conectada e se comunicar com a rede Thread, o ping será bem-sucedido:

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

Se você tiver saído do contêiner do Docker

bash prompts , você pode precisar verificar se ele está em execução e reiniciar / reinserir 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 interrompidos):

$ 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 codelab_otsim_ctnr contêiner codelab_otsim_ctnr na saída de nenhum dos comandos docker ps , execute-o 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 contêiner estiver parado (listado em docker ps -a mas não docker ps ), reinicie-o:

$ docker start -i codelab_otsim_ctnr

Se o contêiner Docker já estiver em execução (listado em docker ps ), reconecte-se ao contêiner em cada terminal:

$ docker exec -it codelab_otsim_ctnr bash

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
  • Nós de thread de autenticação
  • Gerenciar uma rede Thread com OpenThread Daemon

Para saber mais sobre Thread e OpenThread, explore estas referências:

Ou tente usar o OpenThread Border Router em um contêiner do Docker !