Roteador de borda de linha de execução: acesso à Internet via NAT64

1. Introdução

7299534792dd9439.png

O que é Thread?

O Thread é um protocolo de rede mesh sem fio de baixo consumo e baseado em IP que permite a comunicação segura entre dispositivos e na nuvem. As redes de linhas de execução podem se adaptar às mudanças de topologia para evitar falhas de ponto único.

O que é OpenThread?

O OpenThread lançado pelo Google é uma implementação de código aberto do Thread®.

O que é um roteador de borda do OpenThread?

O Roteador de borda do OpenThread (OTBR) lançado pelo Google é uma implementação de código aberto do Roteador de Borda do Thread.

NAT64

NAT64 é um mecanismo que permite que hosts em redes somente IPv6 acessem recursos em redes IPv4. O gateway NAT64 é um tradutor entre protocolos IPv4 e protocolos IPv6.

O tradutor NAT64, como parte do roteador de borda OpenThread, é compatível com a tradução de protocolos TCP, UDP e ICMP (ICMPv6).

O que você vai criar

Neste codelab, você configurará um roteador de borda do OpenThread e um dispositivo Thread e ativará e verificará a comunicação entre dispositivos Thread e hosts IPv4 na Internet por meio do roteador de borda do OpenThread.

O que você vai aprender

  • Como criar um roteador de borda do OpenThread com recursos NAT64
  • Como se comunicar com hosts IPv4 de dispositivos finais Thread.

Pré-requisitos

  • Uma estação de trabalho Linux para criar e atualizar um NThread Thread, a CLI do OpenThread e testar a conectividade IPv4.
  • Um Raspberry Pi 4 com 4 GB de RAM para o roteador de borda Thread. Sua estação de trabalho Linux precisa ser acessível por IPv4 neste dispositivo.
  • 2 placas Nordic Semiconductor nRF52840 DK.

A topologia de rede deste codelab:

c3cd2e081bc052fd.png

2. Configurar roteador de borda do OpenThread

Siga a etapa de configuração do OTBR do roteador de borda do Thread - Conectividade IPv6 bidirecional e descoberta de serviço baseada em DNS para criar o roteador de borda do OpenThread com a seguinte alteração:

Em Criar e instalar o OTBR, você precisa instruir o script para ativar o tradutor NAT64 no OpenThread definindo a variável de ambiente NAT64 como 1 e NAT64_SERVICE como openthread. Execute o seguinte comando antes da etapa:

$ export NAT64=1 NAT64_SERVICE=openthread

Continue com o codelab Roteador de borda do Thread - Conectividade IPv6 bidirecional e Descoberta de serviço baseada em DNS, conforme escrito. Depois de Form a Thread network, verifique se o roteador de borda está publicando um prefixo NAT64 pelos comandos da CLI do OpenThread.

Primeiro, verifique se o roteador de borda está funcionando e se o NAT64 está ativado:

$ sudo ot-ctl state
leader
Done
$ sudo ot-ctl nat64 enable
Done
$ sudo ot-ctl nat64 state
PrefixManager: Active
Translator: Active
Done

Podemos ver que o OTBR está agindo como líder do Thread e há um prefixo NAT64 (no nosso caso) fd4c:9574:3720:2:0:0::/96:

$ sudo ot-ctl netdata show
Prefixes:
fd4c:9574:3720:1::/64 paos low 0800
Routes:
fd49:7770:7fc5:0::/64 s med 0800
fd4c:9574:3720:2:0:0::/96 sn low 0800
Services:
44970 01 41000500000e10 s 0800
44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800
Done

O prefixo NAT64 será usado por dispositivos Thread ao se comunicar com um host IPv4.

3. Configurar dispositivo final do Thread

Siga a etapa Configurar a FTD do codelab Criar uma linha de execução com placas nRF52840 e OpenThread para criar e atualizar um dispositivo final da CLI nRF52840, com uma alteração na etapa a seguir:

Em Build and flash, é necessário anexar -DOT_DNS_CLIENT=ON, -DOT_SRP_CLIENT=ON e -DOT_ECDSA=ON à linha de comando ao chamar script/build:

$ cd ~/src/ot-nrf528xx
$ rm -rf build
$ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON -DOT_DNS_CLIENT=ON -DOT_SRP_CLIENT=ON -DOT_ECDSA=ON

Continue com o codelab Criar uma rede com linhas de execução nRF52840 e OpenThread, conforme escrito. Depois que o dispositivo final for atualizado com a imagem da CLI, siga as etapas em Roteador de borda do Thread: conectividade IPv6 bidirecional e descoberta de serviços baseada em DNS para configurar o dispositivo final.

Aguarde alguns segundos após a configuração do dispositivo final e verifique se a conexão com a rede Thread foi concluída. Você encontrará um prefixo NAT64 dos dados de rede (fd4c:9574:3720:2:0:0::/96 no nosso caso):

> netdata show
Prefixes:
fd4c:9574:3720:1::/64 paos low 0800
Routes:
fd49:7770:7fc5:0::/64 s med 0800
fd4c:9574:3720:2:0:0::/96 sn low 0800
Services:
44970 01 41000500000e10 s 0800
44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800
Done

Verifique se os dados de rede correspondem aos dados de OTBR.

4. Comunicar-se com hosts IPv4 do dispositivo final Thread

Agora você pode se comunicar com os hosts na rede IPv4 a partir do dispositivo final que acabamos de configurar.

Enviar solicitações de eco do ICMP para hosts IPv4

Na CLI do dispositivo final Thread:

> ping 8.8.8.8
Pinging synthesized IPv6 address: fd4c:9574:3720:2:0:0:808:808
16 bytes from fd4c:9574:3720:2:0:0:808:808: icmp_seq=15 hlim=119 time=48ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 48/48.0/48 ms.
Done

O roteador de borda cria um item de mapeamento NAT64 para este dispositivo pelo comando nat64 mappings:

$ sudo ot-ctl nat64 mappings
|                  | Address                                                     |        | 4 to 6                  | 6 to 4                  |
+------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+
| ID               | IPv6                                     | IPv4             | Expiry | Pkts     | Bytes        | Pkts     | Bytes        |
+------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+
| 377ee63dd3127f1a |     fd4c:9574:3720:1:1d61:b4c1:494f:f975 |  192.168.255.254 |  7190s |        1 |           16 |        1 |           16 |
|                  |                                                                  TCP |        0 |            0 |        0 |            0 |
|                  |                                                                  UDP |        0 |            0 |        0 |            0 |
|                  |                                                                 ICMP |        1 |           16 |        1 |           16 |
Done

O fd4c:9574:3720:1:1d61:b4c1:494f:f975 precisa ser o endereço IPv6 do seu dispositivo Thread.

Execute este comando no roteador de borda a qualquer momento para ver como ele conta o tráfego.

Enviar consultas DNS para servidores DNS IPv4

Use dns resolve4 para resolver um nome do host na rede IPv4. O endereço do servidor DNS também pode ser um endereço IPv4:

> dns resolve4 example.com 8.8.8.8
Synthesized IPv6 DNS server address: fd4c:9574:3720:2:0:0:808:808
DNS response for example.com. - fd4c:9574:3720:2:0:0:5db8:d822 TTL:20456 
Done

Comunicação via TCP

É possível estabelecer conexões TCP entre o dispositivo final e os hosts na rede IPv4.

Suponha que o endereço IP do seu host IPv4 do Linux seja 192.168.0.2.

No host IPv4 do Linux, use nc para detectar conexões TCP:

$ nc -l 0.0.0.0 12345

No dispositivo final Thread, estabeleça uma conexão TCP e envie mensagens para seu host IPv4 do Linux:

> tcp init
Done
> tcp connect 192.168.0.2 12345
Connecting to synthesized IPv6 address: fd4c:9574:3720:2:0:0:c0a8:2
Done
> tcp send hello

A saída do host do IPv4 do Linux é:

hello

Você também pode enviar mensagens do seu host IPv4 do Linux para o dispositivo final Thread. Digite "world" e pressione Enter no seu host IPv4 do Linux com nc, e o dispositivo Thread terá como saída:

TCP: Received 6 bytes: world

Comunicação via UDP

É possível se comunicar usando UDP entre dispositivos Thread e hosts na rede IPv4.

Suponha que o endereço IP do seu host IPv4 do Linux seja 192.168.0.2.

Use nc para detectar conexões UDP:

$ nc -u -l 0.0.0.0 12345

No dispositivo final Thread, estabeleça uma conexão UDP e envie mensagens para seu host IPv4 do Linux:

> udp open
Done
> udp connect 192.168.0.2 12345
Connecting to synthesized IPv6 address: fd4c:9574:3720:2:0:0:c0a8:2
Done
> udp send hello
Done

A saída do host do IPv4 do Linux é:

hello

Você também pode enviar mensagens do seu host IPv4 do Linux para o dispositivo final Thread. Digite "world" e pressione Enter no seu host IPv4 do Linux com nc, e o dispositivo Thread terá como saída:

6 bytes from fd4c:9574:3720:2:0:0:c0a8:2 12345 world

5. Alternar NAT64 no roteador de borda

Você pode ativar ou desativar o NAT64 a qualquer momento. Use nat64 disable para desativar o NAT64. Use nat64 state para verificar o estado do NAT64.

$ sudo ot-ctl nat64 disable
Done
$ sudo ot-ctl nat64 state
PrefixManager: Disabled
Translator: Disabled
Done

Após a desativação, o dispositivo não estará mais publicando um prefixo NAT64:

$ sudo ot-ctl netdata show
Prefixes:
fd4c:9574:3720:1::/64 paos low 0800
Routes:
fd49:7770:7fc5:0::/64 s med 0800
Services:
44970 01 41000500000e10 s 0800
44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800
Done

Além disso, os dispositivos na rede Thread não podem mais acessar o host IPv4 por esse roteador de borda.

Na CLI do dispositivo final Thread:

> ping 8.8.8.8
Error 13: InvalidState

Use nat64 enable para ativar o NAT64. Pode levar algum tempo até que o gerenciador de prefixo comece a anunciar um prefixo NAT64:

$ sudo ot-ctl nat64 enable
Done
$ sudo ot-ctl nat64 state
PrefixManager: Idle
Translator: NotWorking
Done

Após alguns segundos, os componentes NAT64 devem estar funcionando:

$ sudo ot-ctl nat64 state
PrefixManager: Active
Translator: Active
Done
$ sudo ot-ctl netdata show
Prefixes:
fd4c:9574:3720:1::/64 paos low 0800
Routes:
fd49:7770:7fc5:0::/64 s med 0800
fd4c:9574:3720:2:0:0::/96 sn low 0800
Services:
44970 01 41000500000e10 s 0800
44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800
Done

A desativação da NAT64 limpará a tabela de mapeamento:

$ sudo ot-ctl nat64 mappings
|                  | Address                                                     |        | 4 to 6                  | 6 to 4                  |
+------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+
| ID               | IPv6                                     | IPv4             | Expiry | Pkts     | Bytes        | Pkts     | Bytes        |
+------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+
Done

6. Encaminhar consultas DNS para servidores DNS upstream

Quando o NAT64 estiver ativado no roteador de borda, o OpenThread tentará encaminhar as consultas DNS de domínios da Internet para servidores DNS upstream.

Essa função é compatível com o servidor DNS-SD interno. Portanto, verifique se o servidor DNS-SD está ativado.

$ sudo ot-ctl srp server state
running
Done

Se não for running, ative-o:

$ sudo ot-ctl srp server enable
Done

Verifique se o proxy DNS upstream está ativado:

$ sudo ot-ctl dns server upstream
Enabled
Done

Se não for Enabled, ative-o:

$ sudo ot-ctl dns server upstream enable
Done

Em dispositivos finais, verifique se o cliente SRP está ativado para enviar consultas DNS ao roteador de borda:

> srp client state
Enabled
Done

Se não for Enabled, ative-o:

> srp client autostart enable
Done

No dispositivo final, verifique se o servidor DNS padrão é o roteador de borda:

> dns config
Server: [fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf]:53
ResponseTimeout: 6000 ms
MaxTxAttempts: 3
RecursionDesired: yes
Done

O endereço IPv6 do servidor (fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf no exemplo acima) precisa ser um dos endereços do roteador de borda do OpenThread.

Agora você pode enviar consultas DNS para domínios da Internet a partir do dispositivo final:

> dns resolve example.com
DNS response for example.com. - 2606:2800:220:1:248:1893:25c8:1946 TTL:8720 
Done
> dns resolve4 example.com
DNS response for example.com. - fd4c:9574:3720:2:0:0:5db8:d822 TTL:20456 
Done

7. Parabéns

Parabéns! Você configurou um roteador de borda compatível com NAT64 e o usou para fornecer acesso à Internet para dispositivos finais do Thread.

Leia mais

Documentos de referência