1. Introducción
¿Qué es Thread?
Thread es un protocolo de red en malla inalámbrica de bajo consumo basado en IP que permite comunicaciones seguras entre dispositivos y entre dispositivos. Las redes de subprocesos pueden adaptarse a los cambios de topología para evitar fallas de un solo punto.
¿Qué es OpenThread?
OpenThread lanzado por Google es una implementación de código abierto de Thread®.
¿Qué es un router de borde OpenThread?
El router de borde de OpenThread (OTBR) que lanzó Google es una implementación de código abierto del router de borde de Thread.
NAT64
NAT64 es un mecanismo que permite que los hosts de redes que solo admiten IPv6 accedan a los recursos de las redes IPv4. La puerta de enlace NAT64 es un traductor entre los protocolos IPv4 y los protocolos IPv6.
El traductor de NAT64, como parte del router de borde de OpenThread, admite la traducción de protocolos TCP, ICMP (ICMPv6) y UDP.
Qué compilarás
En este codelab, configurarás un router de borde de OpenThread y un dispositivo Thread. Luego, habilitarás y verificarás la comunicación entre dispositivos Thread y hosts IPv4 en Internet a través del router de borde de OpenThread.
Qué aprenderás
- Cómo compilar un router de borde OpenThread con funciones de NAT64.
- Cómo comunicarse con hosts IPv4 desde dispositivos extremos de Thread.
Requisitos
- Una estación de trabajo de Linux, para compilar e instalar en la memoria flash un NCP de Thread, la CLI de OpenThread y probar la conectividad IPv4
- Una Raspberry Pi 4 con 4 GB de RAM para el router de borde Thread. Se debería poder acceder a la estación de trabajo de Linux mediante IPv4 desde este dispositivo.
- 2 placas Nordic Semiconductor nRF52840 DK.
La topología de red para este codelab tiene las siguientes características:
2. Configurar el router de borde OpenThread
Sigue el paso de configuración de OTBR del codelab del router de borde Thread: conectividad IPv6 bidireccional y detección de servicios basados en DNS para compilar el router de borde OpenThread con el siguiente cambio:
En Build and install OTBR, debes indicarle a la secuencia de comandos que habilite el traductor de NAT64 en OpenThread mediante la configuración de la variable de entorno NAT64 en 1 y NAT64_SERVICE en openthread. Ejecuta el siguiente comando antes del paso:
$ export NAT64=1 NAT64_SERVICE=openthread
Continúa con el codelab Router de borde de Thread: conectividad IPv6 bidireccional y descubrimiento de servicios basado en DNS como se escribió. Después de formar una red Thread, puedes verificar que el router de borde publique un prefijo NAT64 con los comandos de la CLI de OpenThread.
Primero, asegúrate de que nuestro router de borde esté funcionando y que NAT64 esté habilitado en él:
$ sudo ot-ctl state leader Done $ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Active Translator: Active Done
Deberíamos poder ver que OTBR actúa como líder de Thread y hay un prefijo NAT64 (en nuestro caso, fd4c:9574:3720:2:0:0::/96) en los datos de la red de Thread:
$ 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
Los dispositivos Thread usan el prefijo NAT64 cuando se comunican con un host IPv4.
3. Configurar dispositivo final de Thread
Sigue el paso sobre cómo configurar los FTD del codelab Cómo crear una red Thread con placas nRF52840 y OpenThread para compilar y escribir en la memoria flash un dispositivo final de la CLI nRF52840, con un cambio en el siguiente paso:
En Compilación y escritura en la memoria flash, debes agregar -DOT_DNS_CLIENT=ON, -DOT_SRP_CLIENT=ON y -DOT_ECDSA=ON a la línea de comandos cuando llames a 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
Continúa con el codelab Cómo compilar una red Thread con placas nRF52840 y OpenThread como se indica. Después de escribir en la memoria flash la imagen de la CLI en el dispositivo final, sigue el artículo Router de borde de Thread: conectividad IPv6 bidireccional y descubrimiento de servicios basado en DNS para configurar el dispositivo final de Thread.
Espera unos segundos después de configurar el dispositivo final de Thread y verifica si la unión a la red de Thread se realizó correctamente. Deberías poder encontrar un prefijo NAT64 a partir de los datos de red (fd4c:9574:3720:2:0:0::/96 en nuestro 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
Asegúrate de que los datos de red coincidan con los de OTBR.
4. Comunicarse con hosts IPv4 desde el dispositivo final de Thread
Ahora puedes comunicarte con los hosts en la red IPv4 desde el dispositivo final que acabamos de configurar.
Enviar solicitudes de eco de ICMP a hosts IPv4
Desde la CLI de nuestro dispositivo final de 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
El router de borde crea un elemento de asignación NAT64 para este dispositivo a través del 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
fd4c:9574:3720:1:1d61:b4c1:494f:f975 debe ser la dirección IPv6 de tu dispositivo Thread.
Ejecuta este comando en el router de borde en cualquier momento para ver cómo se cuenta el tráfico.
Envía consultas de DNS a servidores DNS de IPv4
Usa dns resolve4 para resolver un nombre de host en la red IPv4. La dirección del servidor DNS también puede ser una dirección 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
Comunicación a través de TCP
Es posible establecer conexiones TCP entre el dispositivo final y los hosts en la red IPv4.
Supongamos que la dirección IP de tu host IPv4 de Linux es 192.168.0.2.
En tu host IPv4 de Linux, usa nc para escuchar conexiones TCP:
$ nc -l 0.0.0.0 12345
Desde el dispositivo final de Thread, establece una conexión TCP y envía mensajes a tu host IPv4 de 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
El host IPv4 de Linux genera los siguientes resultados:
hello
También puedes enviar mensajes desde tu host IPv4 de Linux al dispositivo final de Thread. Escribe "world" Luego, presiona Intro en tu host IPv4 de Linux que ejecuta nc para que el dispositivo final de Thread genere la siguiente salida:
TCP: Received 6 bytes: world
Comunicación a través de UDP
Es posible comunicarse mediante UDP entre dispositivos Thread y hosts en la red IPv4.
Supongamos que la dirección IP de tu host IPv4 de Linux es 192.168.0.2.
Usa nc para escuchar conexiones UDP:
$ nc -u -l 0.0.0.0 12345
Desde el dispositivo final de Thread, establece una conexión UDP y envía mensajes a tu host IPv4 de 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
El host IPv4 de Linux genera los siguientes resultados:
hello
También puedes enviar mensajes desde tu host IPv4 de Linux al dispositivo final de Thread. Escribe "world" Luego, presiona Intro en tu host IPv4 de Linux que ejecuta nc para que el dispositivo final de Thread genere la siguiente salida:
6 bytes from fd4c:9574:3720:2:0:0:c0a8:2 12345 world
5. Activar o desactivar NAT64 en el router de borde
Puedes habilitar o inhabilitar NAT64 en cualquier momento. Usa nat64 disable para inhabilitar NAT64. Además, usa nat64 state para verificar el estado de NAT64.
$ sudo ot-ctl nat64 disable Done $ sudo ot-ctl nat64 state PrefixManager: Disabled Translator: Disabled Done
Después de la inhabilitación, el dispositivo deja de publicar un prefijo de 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
Además, los dispositivos de la red Thread ya no pueden acceder al host IPv4 a través de este router de borde.
Desde la CLI de nuestro dispositivo final de Thread:
> ping 8.8.8.8 Error 13: InvalidState
Usa nat64 enable para habilitar NAT64. Es posible que el administrador de prefijos tarde un tiempo en comenzar a anunciar un prefijo NAT64:
$ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Idle Translator: NotWorking Done
Después de unos segundos, los componentes de NAT64 deberían estar en funcionamiento:
$ 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
Ten en cuenta que, si inhabilitas NAT64, se borrará la tabla de asignación:
$ sudo ot-ctl nat64 mappings | | Address | | 4 to 6 | 6 to 4 | +------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+ | ID | IPv6 | IPv4 | Expiry | Pkts | Bytes | Pkts | Bytes | +------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+ Done
6. Reenviar consultas de DNS a servidores DNS upstream
Cuando NAT64 está habilitado en el router de borde, OpenThread intenta reenviar las consultas de DNS para dominios de Internet a servidores DNS ascendentes.
Esta función es compatible con el servidor DNS-SD interno, por lo que debes asegurarte de que el servidor DNS-SD esté habilitado.
$ sudo ot-ctl srp server state running Done
Si no es running, habilítala:
$ sudo ot-ctl srp server enable Done
Asegúrate de que el proxy de DNS upstream esté habilitado:
$ sudo ot-ctl dns server upstream Enabled Done
Si no es Enabled, habilítala:
$ sudo ot-ctl dns server upstream enable Done
En los dispositivos finales, asegúrate de que el cliente de SRP esté habilitado para que envíe consultas de DNS al router de borde:
> srp client state Enabled Done
Si no es Enabled, habilítala:
> srp client autostart enable Done
En el dispositivo final, asegúrate de que el servidor DNS predeterminado sea el router de borde:
> dns config Server: [fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf]:53 ResponseTimeout: 6000 ms MaxTxAttempts: 3 RecursionDesired: yes Done
La dirección IPv6 del servidor (fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf en el ejemplo anterior) debe ser una de las direcciones de tu router de borde de OpenThread.
Ahora puedes enviar consultas de DNS para dominios de Internet desde el 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. Felicitaciones
Felicitaciones, configuraste correctamente un router de borde compatible con NAT64 y lo usaste para proporcionar acceso a Internet a los dispositivos finales de Thread.
Lecturas adicionales
- Guías de OpenThread
- Referencia de la CLI de OpenThread
- Referencia de la API de OpenThread para NAT64
- Referencia de la API de OpenThread para DNS ascendente
- Abstracción de la plataforma de OpenThread para DNS