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.

Como simular uma rede Thread usando o OpenThread no Docker

1. Introdução

O 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 disponibilizar aos desenvolvedores a tecnologia usada nos produtos Nest para acelerar o desenvolvimento de produtos de casa conectada.

A especificação do Thread define um protocolo de comunicação entre dispositivos sem fio confiável, seguro e de baixo consumo de energia para aplicativos domésticos. O OpenThread implementa todas as camadas de rede Thread, incluindo IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de malha e roteamento de malha.

Este codelab vai orientar você na simulação de uma rede Thread em dispositivos emulados usando o Docker.

O que você vai aprender

Como configurar o conjunto de ferramentas de build do OpenThread
Como simular uma rede Thread
Como autenticar nós do Thread
Como gerenciar uma rede Thread com o Daemon do OpenThread

O que é necessário

Docker
Conhecimento básico de Linux e roteamento de rede

2. Configurar o Docker

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

Instalar o Docker

Instale o Docker no SO de sua escolha.

Extrair a imagem do Docker

Depois que o Docker for instalado, abra uma janela do terminal e extraia a imagem Docker openthread/environment. Esta imagem apresenta o OpenThread e o OpenThread Daemon pré-criados e prontos para uso neste codelab.

$ docker pull openthread/environment:latest

O download pode levar alguns minutos para ser concluído.

Em uma janela do terminal, inicie um contêiner do Docker pela 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/environment bash

A opção --rm exclui o contêiner quando você sai dele. Não use essa opção se não quiser que o contêiner seja excluído.

Observe as flags, que são necessárias para este codelab:

--sysctl net.ipv6.conf.all.disable_ipv6=0: ativa o IPv6 no contêiner
--cap-add=net_admin: ativa o recurso NET_ADMIN, que permite executar operações relacionadas à rede, como adicionar rotas IP.

No contêiner, você verá um comando semelhante a este:

root@c0f3912a74ff:/#

No exemplo acima, c0f3912a74ff é o ID do contêiner. O ID do contêiner da sua instância do Docker será diferente do que aparece nos prompts deste codelab.

Usar o Docker

Este codelab pressupõe que você já conhece os princípios básicos de uso do Docker. Permaneça no contêiner do Docker durante todo o codelab.

3. Simular uma rede Thread

O aplicativo de exemplo que você usará neste codelab demonstra um aplicativo OpenThread mínimo que expõe as interfaces de configuração e gerenciamento do OpenThread por uma interface de linha de comando (CLI) básica.

Este exercício apresenta as etapas mínimas necessárias para dar um ping em um dispositivo Thread emulado a partir de outro dispositivo Thread emulado.

A figura abaixo descreve uma topologia básica de rede Thread. Neste exercício, vamos emular os dois nós dentro do círculo verde: um líder de linha de execução e um roteador de linha de execução com uma única conexão entre eles.

Criar a rede

1. Nó inicial 1

Caso ainda não tenha feito isso, em uma janela do 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/environment bash

No contêiner do Docker, gere o processo da CLI para um dispositivo Thread emulado usando o binário ot-cli-ftd.

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

Observação:se o prompt > não aparecer depois de executar esse comando, pressione enter.

Esse binário implementa um dispositivo OpenThread. O driver de rádio IEEE 802.15.4 é implementado sobre o UDP (frames IEEE 802.15.4 são passados dentro de payloads de UDP).

O argumento de 1 é um descritor de arquivo que representa os bits menos significativos dos "atribuídos de fábrica". IEEE EUI-64 para o dispositivo emulado. Esse valor também é usado na vinculação a uma porta UDP para emulação de rádio IEEE 802.15.4 (porta = 9000 + descritor do arquivo). Cada instância de um dispositivo Thread emulado neste codelab vai usar um descritor de arquivo diferente.

Observação:use apenas descritores de arquivo de 1 ou mais recentes, conforme observado neste codelab ao gerar o processo para um dispositivo emulado. Um descritor de arquivo de 0 está reservado para outro uso.

Criar um novo conjunto de dados operacional e fazer commit dele 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 o 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 líder de linha de execução. O líder é o dispositivo responsável por gerenciar a atribuição do ID do roteador.

> state
leader
Done

Confira 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ços 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 mais:

Contém ff:fe00 = Router Locator (RLOC)
Não contém ff:fe00 = identificador de endpoint (EID, na sigla em inglês)

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

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

2. Nó inicial 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 comando bash, gere o processo da CLI com o argumento 2. Este é o segundo dispositivo Thread emulado:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2

Observação:se o prompt > não aparecer depois de executar esse comando, pressione enter.

Configure a chave de rede de linha de execução 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 o ativo:

> dataset commit active
Done

Abra a interface IPv6:

> ifconfig up
Done

Inicie a operação do protocolo Thread:

> thread start
Done

O dispositivo será inicializado como um filho. Um Thread Child é equivalente a um dispositivo final, que é um dispositivo Thread que transmite e recebe tráfego unicast somente com um dispositivo pai.

> state
child
Done

Em até dois minutos, a mudança de estado de child para router será mostrada. Um roteador Thread é capaz de rotear o tráfego entre dispositivos Thread. Ele também é chamado de "Pai".

> state
router
Done

Verificar a rede

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

1. Verificar a conectividade:

No Nó 2, acesse o RLOC16. O RLOC16 são os últimos 16 bits do endereço RLOC IPv6 do dispositivo.

> rloc16
5800
Done

No Nó 1, verifique na tabela do roteador o RLOC16 do Nó 2. Primeiro, verifique se o Nó 2 mudou 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 |

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

2. Dê um ping no nó 1 a partir do nó 2

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

Testar a rede

Agora que você consegue dar um ping entre dois dispositivos Thread emulados, teste a rede mesh colocando um nó off-line.

Volte para o nó 1 e pare a linha de execução:

> thread stop
Done

Alterne para o Nó 2 e verifique o estado. Em dois minutos, o Nó 2 detectará que o líder (Nó 1) está off-line, e a transição do Nó 2 deverá ser o leader da rede:

> state
router
Done
...
> state
leader
Done

Após a confirmação, interrompa o Thread e redefina o Node 2 para a configuração original antes de voltar para o comando bash do Docker. 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.

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

Talvez seja necessário pressionar enter algumas vezes para trazer o prompt > de volta após um comando factoryreset. Não saia do contêiner do Docker.

Redefina também para a configuração original e saia do Nó 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Consulte a Referência da CLI do OpenThread para explorar todos os comandos disponíveis da CLI.

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 permite apenas que o tráfego link-local IPv6 não autenticado passe entre dispositivos. Para rotear o tráfego IPv6 global entre eles (e a Internet por meio de um roteador de borda Thread), os nós precisam ser autenticados.

Para autenticar um dispositivo, ele precisa atuar como Comissário. O comissário é o servidor de autenticação eleito para novos dispositivos Thread e o autorizador a fornecer as credenciais de rede necessárias para que os dispositivos entrem na rede.

Neste exercício, usaremos a mesma topologia de dois nós de antes. Para autenticação, o líder do Thread vai atuar como o comissário, e o roteador do Thread como um Joiner.

Docker

Para cada nó (janela do terminal) nos exercícios restantes, verifique se você está executando o contêiner do Docker com o build do OpenThread. Se você continuar do exercício anterior, ainda terá dois prompts bash abertos no mesmo contêiner do Docker. Caso contrário, consulte a etapa Solução de problemas do Docker ou refaça o exercício Simular uma rede Thread.

1. Criar uma rede

No Nó 1, gere o processo da CLI:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

Observação:se o prompt > não aparecer depois de executar esse comando, pressione enter.

Crie um novo conjunto de dados operacional, confirme-o como o ativo e inicie a linha de execução:

> 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 o 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 líder de linha de execução:

> state
leader
Done

2. Começar a função de Comissário

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

> commissioner start
Done

Permita que qualquer Joiner (usando o caractere curinga *) com a credencial J01NME seja comissionado na rede. Um Joiner é um dispositivo adicionado por um administrador humano a uma rede Thread comissionada.

> commissioner joiner add * J01NME
Done

3. Inicie a função de Combinador

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

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2

No Nó 2, ative o papel de Joiner usando a credencial de Joiner J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

Aguarde alguns segundos pela confirmação...

Join success

Como Joiner, o dispositivo (nó 2) se autenticou com o Commissioner (Nó 1) e recebeu as credenciais da rede Thread.

Agora que o Node 2 está autenticado, inicie a Thread:

> thread start
Done

4. Validar a autenticação de rede

Verifique o state no nó 2 para confirmar que agora ele está conectado à rede. Em dois minutos, o nó 2 faz 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 para a configuração original e saia do dispositivo Thread emulado:

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

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

5. Gerenciar a rede com o OpenThread Daemon

Para este exercício, vamos simular uma instância de CLI (um único dispositivo de Thread SoC incorporado) e uma instância de coprocessador de rádio (RCP).

ot-daemon é um modo do app OpenThread Posix que usa um soquete UNIX como entrada e saída. Assim, o núcleo do OpenThread pode ser executado como um serviço. Um cliente pode se comunicar com esse 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. Com isso, vamos conectar o RCP à rede criada pelo dispositivo Thread.

Docker

Para cada nó (janela do terminal) neste exercício, verifique se você está executando o contêiner do Docker com o build do OpenThread. Se continuar o exercício anterior, você terá dois prompts bash abertos no mesmo contêiner do Docker. Caso contrário, consulte a etapa Solução de problemas do Docker.

Usar ot-daemon

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

Instância da CLI do dispositivo Thread simulado (nó 1)
Processo ot-daemon
Instância da CLI ot-ctl

1. Nó inicial 1

Na primeira janela do terminal, gere o processo da CLI para seu dispositivo Thread emulado:

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1

Observação:se o prompt > não aparecer depois de executar esse comando, pressione enter.

Crie um novo conjunto de dados operacional, confirme-o como o ativo e inicie a linha de execução:

> 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 o ativo:

> dataset commit active
Done

Abra a interface IPv6:

> ifconfig up
Done

Inicie a operação do protocolo Thread:

> thread start
Done

Confira os endereços IPv6 atribuídos à interface da linha de execução 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 Simular uma rede Thread, um endereço é link-local (fe80) e três são mesh-local (fd). O EID é o endereço local da malha 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 da saída do ipaddr, que será usado para se comunicar com o nó.

2. Iniciar ot-daemon

Na janela do segundo terminal, crie um nó de 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

Esse dispositivo é usado para transmissão e recebimento de pacotes em dispositivos virtuais. Você poderá receber um erro se o dispositivo já tiver sido criado. Isso é normal e pode ser ignorado.

Inicie ot-daemon para um nó de RCP, que vamos chamar de Nó 2. Use a sinalização detalhada -v para ver a saída do registro e confirmar se ela está em execução:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'

Quando bem-sucedido, ot-daemon no modo detalhado gera uma saída semelhante a esta:

ot-daemon[31]: Running OPENTHREAD/297a880; POSIX; Feb  1 2022 04:43:39
ot-daemon[31]: Thread version: 3
ot-daemon[31]: Thread interface: wpan0
ot-daemon[31]: RCP version: OPENTHREAD/297a880; SIMULATION; Feb  1 2022 04:42:50

Deixe esse terminal aberto e em execução em segundo plano. Você não inserirá outros comandos nele.

3. Usar ot-ctl para fazer conexão com a rede

Ainda não comissionamos o nó 2 (o RCP ot-daemon) em nenhuma rede Thread. É aí que entra a ot-ctl. ot-ctl usa a mesma CLI que o app da CLI do OpenThread. Portanto, você pode controlar os nós ot-daemon da mesma forma que os outros dispositivos Thread simulados.

Abra uma terceira janela do terminal e execute o contêiner atual:

$ docker exec -it codelab_otsim_ctnr bash

No contêiner, inicie ot-ctl:

root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl
>

Use o ot-ctl nesta janela do terceiro terminal para gerenciar o nó 2 (o nó do RCP) iniciado na janela do segundo terminal com ot-daemon. Verifique o state do nó 2:

> state
disabled
Done

Consiga o eui64 do nó 2 para restringir a mesclagem ao Joiner específico:

> eui64
18b4300000000001
Done

No nó 1 (primeira janela do terminal), inicie o Commissioner e restrinja a mesclagem apenas a esse eui64:

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

Na terceira janela do terminal, acesse a interface de rede do Nó 2 e entre na rede:

> ifconfig up
Done
> joiner start J01NME
Done

Aguarde alguns segundos pela confirmação...

Join success

Como Joiner, o RCP (Nó 2) se autenticou com sucesso no Commissioner (Nó 1) e recebeu as credenciais da rede Thread.

Agora vincule o nó 2 à rede Thread (novamente, na terceira janela de terminal):

> thread start
Done

4. Validar a autenticação de rede

No terceiro terminal, verifique o state no nó 2 para confirmar que ele está conectado à rede. Em dois minutos, o nó 2 faz a transição de child para router:

> state
child
Done
...
> state
router
Done

5. Validar a conectividade

Na terceira janela do terminal, saia do ot-ctl usando o comando Ctrl+D ou exit e volte ao console bash do contêiner. Nesse console, dê um ping no nó 1 usando o EID dele com o comando ping6. Se a instância do RCP ot-daemon for associada 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

6. Solução de problemas do Docker

Se você saiu do contêiner do Docker

bash solicitações, talvez seja necessário verificar se ele está em execução e reiniciar / inserir novamente conforme necessário. Todos os contêineres do Docker que você criou onde não usou a opção --rm ainda existem.

Para mostrar quais contêineres do Docker estão em execução:

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        environment       "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        environment       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Se o contêiner codelab_otsim_ctnr não aparecer na saída de um comando 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/environment bash

Use a opção --rm apenas se quiser que o contêiner seja excluído ao sair dele.

Se o contêiner for interrompido (listado em docker ps -a, mas não em docker ps), reinicie-o:

$ docker start -i codelab_otsim_ctnr

Se o contêiner do 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

"Operação não permitida" erros

Se você encontrar erros Operation not permitted ao criar novos nós do OpenThread (usando o comando mknod), verifique se está executando o Docker como usuário raiz, de acordo com os comandos fornecidos neste codelab. Este codelab não é compatível com a execução do Docker no modo sem raiz.

7. Parabéns!

Você simulou sua primeira rede Thread usando o OpenThread. Incrível!

Neste codelab, você aprendeu a:

Iniciar e gerenciar o contêiner do Docker de simulação do OpenThread
Simular uma rede Thread
Autenticar nós do Thread
Gerenciar uma rede Thread com o OpenThread Daemon

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

Outra opção é usar o roteador de borda do OpenThread em um contêiner do Docker (link em inglês).