1. Introducción
OpenThread, lanzado por Google, es una implementación de código abierto del protocolo de redes Thread. Google Nest lanzó OpenThread para que los desarrolladores puedan acceder a la tecnología que se usa en los productos Nest y, así, acelerar el desarrollo de productos para la casa conectada.
La especificación de Thread define un protocolo de comunicación inalámbrico confiable, seguro y de bajo consumo basado en IPv6 para aplicaciones domésticas. OpenThread implementa todas las capas de red de Thread, incluidas IPv6, 6LoWPAN, IEEE 802.15.4 con seguridad MAC, establecimiento de vínculos de malla y enrutamiento de malla.
En este codelab, se te guiará para simular una red de Thread en dispositivos emulados con Docker.
Qué aprenderás
- Cómo configurar la cadena de herramientas de compilación de OpenThread
- Cómo simular una red de Thread
- Cómo autenticar nodos de Thread
- Cómo administrar una red de Thread con el daemon de OpenThread
Requisitos
- Docker
- Conocimientos básicos de Linux y enrutamiento de redes
2. Configurar Docker
Este Codelab está diseñado para usar Docker en una máquina con Linux, Mac OS X o Windows. Se recomienda usar Linux.
Instala Docker
Instala Docker en el SO que elijas.
Extrae la imagen de Docker
Una vez que se instale Docker, abre una ventana de la terminal y extrae la imagen de Docker openthread/environment. Esta imagen incluye OpenThread y el daemon de OpenThread prediseñados y listos para usar en este codelab.
$ docker pull openthread/environment:latest
Ten en cuenta que la descarga puede tardar unos minutos en completarse.
En una ventana de la terminal, inicia un contenedor de Docker desde la imagen y conéctate a su 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
La opción --rm borra el contenedor cuando sales de él. No uses esta opción si no quieres que se borre el contenedor.
Ten en cuenta las marcas, que son obligatorias para este codelab:
--sysctl net.ipv6.conf.all.disable_ipv6=0: Habilita IPv6 dentro del contenedor.--cap-add=net_admin: Habilita la capacidad NET_ADMIN, que te permite ejecutar operaciones relacionadas con la red, como agregar rutas de IP.
Una vez que estés en el contenedor, deberías ver un mensaje similar al siguiente:
root@c0f3912a74ff:/#
En el ejemplo anterior, c0f3912a74ff es el ID del contenedor. El ID del contenedor de tu instancia del contenedor de Docker será diferente del que se muestra en las instrucciones de este codelab.
Usa Docker
En este codelab, se supone que conoces los conceptos básicos del uso de Docker. Debes permanecer en el contenedor de Docker durante todo el codelab.
3. Cómo simular una red de Thread
La aplicación de ejemplo que usarás para este codelab muestra una aplicación mínima de OpenThread que expone las interfaces de configuración y administración de OpenThread a través de una interfaz de línea de comandos (CLI) básica.
En este ejercicio, se explican los pasos mínimos necesarios para enviar un ping de un dispositivo Thread emulado a otro.
En la siguiente figura, se describe una topología de red de Thread básica. Para este ejercicio, emularemos los dos nodos dentro del círculo verde: un líder de Thread y un router de Thread con una sola conexión entre ellos.
Crea la red
1. Nodo de inicio 1
Si aún no lo hiciste, en una ventana de terminal, inicia el contenedor de Docker y conéctate a su 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
En el contenedor de Docker, genera el proceso de la CLI para un dispositivo Thread emulado con el objeto binario ot-cli-ftd.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.
Este objeto binario implementa un dispositivo OpenThread. El controlador de radio IEEE 802.15.4 se implementa sobre UDP (los marcos IEEE 802.15.4 se pasan dentro de las cargas útiles de UDP).
El argumento de 1 es un descriptor de archivo que representa los bits menos significativos del EUI-64 IEEE "asignado de fábrica" para el dispositivo emulado. Este valor también se usa cuando se vincula a un puerto UDP para la emulación de radio IEEE 802.15.4 (puerto = 9000 + descriptor de archivo). Cada instancia de un dispositivo Thread emulado en este codelab usará un descriptor de archivo diferente.
Nota: Cuando generes el proceso para un dispositivo emulado, usa solo descriptores de archivos de 1 o superiores, como se indica en este codelab. Un descriptor de archivo de 0 está reservado para otro uso.
Crea un nuevo conjunto de datos operacionales y confirma que sea el activo. El conjunto de datos operativo es la configuración de la red Thread que estás creando.
> 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
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up Done
Operación del protocolo Start Thread:
> thread start Done
Espera unos segundos y verifica que el dispositivo se haya convertido en el líder de la red Thread. El líder es el dispositivo responsable de administrar la asignación de IDs de router.
> state leader Done
Consulta las direcciones IPv6 asignadas a la interfaz de Thread del nodo 1 (el resultado 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
Ten en cuenta los tipos de direcciones IPv6 específicos:
- Comienza con
fd= mesh-local - Comienza con
fe80= vínculo local
Los tipos de direcciones locales de malla se clasifican de la siguiente manera:
- Contiene
ff:fe00= Localizador de router (RLOC) - No contiene
ff:fe00= Identificador de extremo (EID)
Identifica el EID en el resultado de la consola y toma nota de él para usarlo más adelante. En el resultado de muestra anterior, el EID es el siguiente:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Nodo 2 de inicio
Abre una terminal nueva y ejecuta un shell bash en el contenedor de Docker que se está ejecutando actualmente para usarlo en el nodo 2.
$ docker exec -it codelab_otsim_ctnr bash
En esta nueva instrucción bash, genera el proceso de la CLI con el argumento 2. Este es tu segundo dispositivo Thread emulado:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.
Configura la clave de red de Thread y el ID de PAN con los mismos valores que el conjunto de datos operativos del nodo 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up Done
Operación del protocolo Start Thread:
> thread start Done
El dispositivo se inicializará como hijo. Un dispositivo secundario de Thread equivale a un dispositivo final, que es un dispositivo de Thread que transmite y recibe tráfico de unidifusión solo con un dispositivo principal.
> state child Done
En un plazo de 2 minutos, deberías ver el cambio de estado de child a router. Un router Thread puede enrutar el tráfico entre dispositivos Thread. También se conoce como elemento principal.
> state router Done
Verifica la red
Una forma sencilla de verificar la red de malla es consultar la tabla del router.
1. Verifica la conectividad.
En el nodo 2, obtén el RLOC16. El RLOC16 son los últimos 16 bits de la dirección IPv6 del RLOC del dispositivo.
> rloc16 5800 Done
En el nodo 1, verifica la tabla de enrutamiento del RLOC16 del nodo 2. Primero, asegúrate de que el nodo 2 haya cambiado al estado de router.
> 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 |
El RLOC de 0x5800 del nodo 2 se encuentra en la tabla, lo que confirma que está conectado a la malla.
2. Haz ping al nodo 1 desde el nodo 2
Verifica la conectividad entre los dos dispositivos Thread emulados. En el nodo 2, ping el EID asignado al nodo 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
Presiona enter para volver al símbolo del sistema de la CLI de >.
Prueba la red
Ahora que puedes hacer ping correctamente entre dos dispositivos Thread emulados, prueba la red de malla desconectando un nodo.
Regresa al nodo 1 y detén el subproceso:
> thread stop Done
Cambia al nodo 2 y verifica el estado. En un plazo de dos minutos, el nodo 2 detecta que el líder (nodo 1) no está conectado, y deberías ver que el nodo 2 pasa a ser el leader de la red:
> state router Done ... > state leader Done
Una vez que se confirme, detén Thread y restablece la configuración de fábrica del nodo 2 antes de salir del mensaje de bash de Docker. El restablecimiento de la configuración de fábrica se realiza para garantizar que las credenciales de la red Thread que usamos en este ejercicio no se transfieran al siguiente.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Es posible que debas presionar enter varias veces para que vuelva a aparecer el mensaje > después de un comando factoryreset. No salgas del contenedor de Docker.
También restablece la configuración de fábrica y sal del nodo 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Consulta la Referencia de la CLI de OpenThread para explorar todos los comandos de la CLI disponibles.
4. Cómo autenticar nodos con Commissioning
En el ejercicio anterior, configuraste una red de Thread con dos dispositivos simulados y verificaste la conectividad. Sin embargo, esto solo permite que el tráfico local de vínculo IPv6 no autenticado pase entre dispositivos. Para enrutar el tráfico IPv6 global entre ellos (y a Internet a través de un router de borde de Thread), los nodos deben autenticarse.
Para autenticar, un dispositivo debe actuar como comisionado. El comisionado es el servidor de autenticación elegido actualmente para los dispositivos Thread nuevos y el autorizador para proporcionar las credenciales de red necesarias para que los dispositivos se unan a la red.
En este ejercicio, usaremos la misma topología de dos nodos que antes. Para la autenticación, el líder de Thread actuará como comisionado y el router de Thread como un dispositivo que se une.
Docker
Para cada nodo (ventana de terminal) en los ejercicios restantes, asegúrate de ejecutar el contenedor de Docker con la compilación de OpenThread. Si continúas desde el ejercicio anterior, deberías tener dos mensajes de bash dentro del mismo contenedor de Docker ya abiertos. De lo contrario, consulta el paso Solución de problemas de Docker o simplemente vuelve a hacer el ejercicio Simula una red de Thread.
1. Crea una red
En el nodo 1, genera el proceso de la CLI:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.
Crea un nuevo conjunto de datos operativos, confirma que sea el activo y, luego, inicia el subproceso:
> 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
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up Done
Operación del protocolo Start Thread:
> thread start Done
Espera unos segundos y verifica que el dispositivo se haya convertido en líder de Thread:
> state leader Done
2. Cómo iniciar el rol de comisionado
Mientras sigues en el nodo 1, inicia el rol de comisionado:
> commissioner start Done
Permite que cualquier Joiner (con el comodín *) con la credencial de Joiner J01NME obtenga una comisión en la red. Un dispositivo Joiner es un dispositivo que un administrador humano agrega a una red de Thread comisionada.
> commissioner joiner add * J01NME Done
3. Cómo iniciar el rol de Joiner
En una segunda ventana de la terminal, en el contenedor de Docker, genera un nuevo proceso de CLI. Este es el nodo 2.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
En el nodo 2, habilita el rol de Joiner con la credencial de Joiner J01NME.
> ifconfig up Done > joiner start J01NME Done
… espera unos segundos para la confirmación…
Join success
Como dispositivo de unión, el dispositivo (nodo 2) se autenticó correctamente con el comisionado (nodo 1) y recibió las credenciales de la red de Thread.
Ahora que el nodo 2 está autenticado, inicia Thread:
> thread start Done
4. Valida la autenticación de red
Verifica el state en el nodo 2 para validar que ahora se unió a la red. En un plazo de dos minutos, el nodo 2 pasa de child a router:
> state child Done ... > state router Done
5. Restablecer configuración
Para prepararte para el siguiente ejercicio, restablece la configuración. En cada nodo, detén Thread, restablece la configuración de fábrica y sal del dispositivo Thread emulado:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Es posible que debas presionar enter varias veces para que vuelva a aparecer el mensaje > después de un comando factoryreset.
5. Administra la red con el daemon de OpenThread
Para este ejercicio, simularemos una instancia de CLI (un solo dispositivo SoC Thread integrado) y una instancia de coprocesador de radio (RCP).
ot-daemon es un modo de la app de OpenThread Posix que usa un socket de UNIX como entrada y salida, de modo que el núcleo de OpenThread pueda ejecutarse como un servicio. Un cliente puede comunicarse con este servicio conectándose al socket con la CLI de OpenThread como protocolo.
ot-ctl es una CLI que proporciona ot-daemon para administrar y configurar el RCP. Con esto, conectaremos el RCP a la red creada por el dispositivo Thread.
Docker
Para cada nodo (ventana de terminal) de este ejercicio, asegúrate de ejecutar el contenedor de Docker con la compilación de OpenThread. Si continúas desde el ejercicio anterior, ya deberías tener dos mensajes de bash abiertos en el mismo contenedor de Docker. De lo contrario, consulta el paso Solución de problemas de Docker.
Cómo usar ot-daemon
En este ejercicio, se usarán tres ventanas de terminal, que corresponden a lo siguiente:
- Instancia de CLI del dispositivo Thread simulado (nodo 1)
- Proceso de
ot-daemon - Instancia de la CLI de
ot-ctl
1. Nodo de inicio 1
En la primera ventana de la terminal, genera el proceso de la CLI para tu dispositivo Thread emulado:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: Si no ves el mensaje > después de ejecutar este comando, presiona enter.
Crea un nuevo conjunto de datos operativos, confirma que sea el activo y, luego, inicia el subproceso:
> 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
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Activa la interfaz IPv6:
> ifconfig up Done
Operación del protocolo Start Thread:
> thread start Done
Consulta las direcciones IPv6 asignadas a la interfaz de Thread del nodo 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 >
Como se explicó en el paso Simula una red de Thread, una dirección es de vínculo local (fe80) y tres son locales de malla (fd). El EID es la dirección local de malla que no contiene ff:fe00 en la dirección. En este resultado de ejemplo, el EID es fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Identifica el EID específico en el resultado de ipaddr, que se usará para comunicarse con el nodo.
2. Inicia ot-daemon
En la segunda ventana de la terminal, crea un nodo de dispositivo tun y establece permisos de lectura y escritura:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
Este dispositivo se usa para la transmisión y recepción de paquetes en dispositivos virtuales. Es posible que recibas un error si el dispositivo ya se creó. Esto es normal y se puede ignorar.
Inicia ot-daemon para un nodo de RCP, al que llamaremos Nodo 2. Usa la marca detallada -v para que puedas ver el resultado del registro y confirmar que se está ejecutando:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \ 'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'
Cuando se ejecuta de forma correcta, ot-daemon en modo detallado genera un resultado similar al siguiente:
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
Deja esta terminal abierta y ejecutándose en segundo plano. No ingresarás ningún otro comando.
3. Usa ot-ctl para unirte a la red
Aún no asignamos el nodo 2 (el RCP ot-daemon) a ninguna red Thread. Aquí es donde entra en juego ot-ctl. ot-ctl usa la misma CLI que la app de la CLI de OpenThread. Por lo tanto, puedes controlar los nodos de ot-daemon de la misma manera que los otros dispositivos Thread simulados.
Abre una tercera ventana de terminal y ejecuta el contenedor existente:
$ docker exec -it codelab_otsim_ctnr bash
Una vez que estés en el contenedor, inicia ot-ctl:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
Usarás ot-ctl en esta tercera ventana de terminal para administrar el nodo 2 (el nodo de RCP) que iniciaste en la segunda ventana de terminal con ot-daemon. Verifica el state del nodo 2:
> state disabled Done
Obtén el eui64 del nodo 2 para restringir la unión al Joiner específico:
> eui64 18b4300000000001 Done
En el nodo 1 (primera ventana de terminal), inicia el comisionado y restringe la unión solo a ese EUI64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
En la tercera ventana de la terminal, activa la interfaz de red del nodo 2 y únete a la red:
> ifconfig up Done > joiner start J01NME Done
… espera unos segundos para la confirmación…
Join success
Como dispositivo de unión, el RCP (nodo 2) se autenticó correctamente con el comisionado (nodo 1) y recibió las credenciales de la red de Thread.
Ahora, une el nodo 2 a la red de Thread (nuevamente, en la tercera ventana de la terminal):
> thread start Done
4. Valida la autenticación de red
En la tercera terminal, verifica state en el nodo 2 para validar que ahora se unió a la red. En un plazo de dos minutos, el nodo 2 pasa de child a router:
> state child Done ... > state router Done
5. Valida la conectividad
En la tercera ventana de la terminal, sal de ot-ctl con el comando Ctrl + D o exit, y regresa a la consola bash del contenedor. Desde esta consola, haz ping al nodo 1 con su EID y el comando ping6. Si la instancia de RCP de ot-daemon se une correctamente a la red de Thread y se comunica con ella, el ping se realiza correctamente:
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. Solución de problemas de Docker
Si saliste del contenedor de Docker
bash indicaciones, es posible que debas verificar si se está ejecutando y reiniciarla o volver a ingresarla según sea necesario. Los contenedores de Docker que creaste y en los que no usaste la opción --rm deberían seguir existiendo.
Para mostrar qué contenedores de Docker se están ejecutando, haz lo siguiente:
$ 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 los contenedores de Docker (tanto los que están en ejecución como los que están detenidos), haz lo siguiente:
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Si no ves el contenedor codelab_otsim_ctnr en el resultado de ninguno de los comandos docker ps, vuelve a ejecutarlo:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
Solo usa la opción --rm si quieres que se borre el contenedor cuando salgas de él.
Si el contenedor está detenido (aparece en docker ps -a, pero no en docker ps), reinícialo:
$ docker start -i codelab_otsim_ctnr
Si el contenedor de Docker ya se está ejecutando (aparece en docker ps), vuelve a conectarte al contenedor en cada terminal:
$ docker exec -it codelab_otsim_ctnr bash
Errores de "Operación no permitida"
Si tienes errores de Operation not permitted cuando creas nodos nuevos de OpenThread (con el comando mknod), asegúrate de ejecutar Docker como usuario raíz según los comandos que se proporcionan en este codelab. Este Codelab no admite la ejecución de Docker en modo sin raíz.
7. ¡Felicitaciones!
Simulaste correctamente tu primera red de Thread con OpenThread. ¡Genial!
En este Codelab aprendiste a hacer lo siguiente:
- Cómo iniciar y administrar el contenedor de Docker de simulación de OpenThread
- Cómo simular una red de Thread
- Autentica nodos de Thread
- Administra una red de Thread con el daemon de OpenThread
Para obtener más información sobre Thread y OpenThread, explora estas referencias:
- Guía básica de Thread en openthread.io
- Especificación de Thread
- Repositorio de GitHub de OpenThread
- Referencia de la CLI de OpenThread
- Compatibilidad adicional con OpenThread Docker
O bien, prueba OpenThread Border Router en un contenedor de Docker.