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 de dispositivo a dispositivo y de dispositivo a nube. Las redes de Thread 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 de OpenThread?
El router de borde de Thread (OTBR) lanzado por 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 en redes que son solo IPv6 accedan a los recursos en redes IPv4. La puerta de enlace NAT64 es un traductor entre los protocolos IPv4 e IPv6.
El traductor NAT64, como parte de OpenThread Border Router, permite traducir los protocolos ICMP (ICMP6), TCP y UDP.
Qué compilarás
En este codelab, configurarás un router de borde de Thread y un dispositivo de Thread. Luego, habilitarás y verificarás la comunicación entre los dispositivos de Thread y los hosts de IPv4 en Internet mediante el router de borde de OpenThread.
Qué aprenderás
- Cómo compilar un router de borde de OpenThread con funciones NAT64
- Cómo comunicarse con hosts IPv4 desde dispositivos finales de Thread
Requisitos
- Una estación de trabajo de Linux para compilar y escribir 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 La estación de trabajo Linux debe ser accesible a través de IPv4 desde este dispositivo.
- 2 placas DK Nordic Semiconductor nRF52840.
Topología de red de este codelab:
2. Configurar el router de borde de OpenThread
Sigue el paso OTBR de configuración del router de borde de Thread - Codelab de detección de conectividad IPv6 y servicio basados en DNS para compilar el router de borde de Thread, con los siguientes cambios:
En Build and install OTBR, debe indicarle a la secuencia de comandos que habilite el traductor 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 Thread Border Router: Conectividad IPv6 bidireccional y descubrimiento de servicios basados en DNS, tal como está escrito. Después de formar una red de Thread, puedes verificar que el router de borde publique un prefijo NAT64 mediante los comandos de la CLI de OpenThread.
En primer lugar, asegúrese de que nuestro router de borde esté en funcionamiento 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 (fd4c:9574:3720:2:0:0::/96 en nuestro caso) en los datos de 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 usarán el prefijo NAT64 cuando se comuniquen con un host IPv4.
3. Cómo configurar un dispositivo final Thread
Sigue las instrucciones del artículo Cómo configurar el FTD del módulo Build a Thread con placas nRF52840 y OpenThread para compilar y escribir en la memoria flash un dispositivo final 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 la compilación de una red Thread con placas nRF52840 y un codelab de OpenThread como se indica. Una vez que el dispositivo final se actualice con la imagen de la CLI, sigue Router de borde de Thread - Conectividad IPv6 bidireccional y descubrimiento de servicios basados en DNS para configurar el dispositivo final de Thread.
Espera unos segundos después de configurar el dispositivo final de Thread y verifica si puedes unirte a la red. Deberías poder encontrar un prefijo NAT64 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 el de OTBR.
4. Cómo comunicarse con hosts IPv4 desde el dispositivo final Thread
Ahora puede comunicarse con hosts en la red IPv4 desde el dispositivo final que acabamos de configurar.
Envía solicitudes de eco ICMP a hosts IPv4
Desde la CLI de nuestro 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
El router de borde crea un elemento de asignación NAT64 para este dispositivo con el 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.
Puede ejecutar este comando en el router de borde en cualquier momento para ver cómo registra el tráfico.
Envía consultas de DNS a servidores DNS 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
Comunicarse mediante TCP
Es posible establecer conexiones TCP entre el dispositivo final y los hosts en la red IPv4.
Supongamos que la dirección IP del host IPv4 de Linux es 192.168.0.2.
En tu host IPv4 de Linux, usa nc para escuchar las conexiones TCP:
$ nc -l 0.0.0.0 12345
Desde tu dispositivo final Thread, establece una conexión TCP y envía mensajes al 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 de IPv4 genera lo siguiente:
hello
También puedes enviar mensajes desde tu host IPv4 de Linux al dispositivo final de Thread. Escribe "world" y presiona Intro en el host IPv4 de Linux que ejecute nc para que el dispositivo final del subproceso obtenga resultados:
TCP: Received 6 bytes: world
Comunicarse mediante UDP
Es posible comunicarse mediante UDP entre dispositivos y hosts de Thread en la red IPv4.
Supongamos que la dirección IP del host IPv4 de Linux es 192.168.0.2.
Usa nc para escuchar las conexiones UDP:
$ nc -u -l 0.0.0.0 12345
Desde tu dispositivo final Thread, establece una conexión UDP y envía mensajes al 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 de IPv4 genera lo siguiente:
hello
También puedes enviar mensajes desde tu host IPv4 de Linux al dispositivo final de Thread. Escribe "world" y presiona Intro en el host IPv4 de Linux que ejecute nc para que el dispositivo final del subproceso obtenga resultados:
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. Y 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 ya no publica un prefijo 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 Thread:
> ping 8.8.8.8 Error 13: InvalidState
Usa nat64 enable para habilitar NAT64. Es posible que el administrador de prefijos demore 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 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. Reenvía consultas de DNS a servidores DNS ascendentes
Cuando se habilite NAT64 en el router de borde, OpenThread intentará 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 debe asegurarse 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 ascendente 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úrese de que el cliente 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 tu 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