1. Introducción
OpenThread, lanzado por Google, es una implementación de código abierto del protocolo de red Thread. Google Nest lanzó OpenThread para poner a disposición de los desarrolladores la tecnología que se usa en los productos Nest a fin de acelerar el desarrollo de productos para el hogar conectado.
La especificación de Thread define un protocolo de comunicación de dispositivos inalámbricos, confiable, seguro y de bajo consumo basado en IPv6 para las aplicaciones del hogar. OpenThread implementa todas las capas de herramientas de redes 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, aprenderás a simular una red 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 Thread
- Cómo autenticar nodos de Thread
- Cómo administrar una red Thread con Daemon de OpenThread
Requisitos
- Docker
- Conocimiento básico de Linux, enrutamiento de red
2. Configura Docker
Este Codelab está diseñado para usar Docker en una máquina con Linux, Mac OS X o Windows. Linux es el entorno recomendado.
Instala Docker
Instala Docker en el SO que prefieras.
Extrae la imagen de Docker
Una vez que Docker esté instalado, abre una ventana de la terminal y extrae la imagen de Docker openthread/environment
. En esta imagen, se incluyen OpenThread y OpenThread Daemon compilados con anterioridad y listos para usar en este Codelab.
$ docker pull openthread/environment:latest
Ten en cuenta que la descarga puede tardar unos minutos.
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
Ten en cuenta las marcas necesarias para este codelab:
--sysctl net.ipv6.conf.all.disable_ipv6=0
: Esto habilita IPv6 dentro del contenedor--cap-add=net_admin
: Habilita la función NET_ADMIN, que te permite ejecutar operaciones relacionadas con la red, como agregar rutas de IP.
Una vez 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 de contenedor de tu instancia del contenedor de Docker será diferente del que se muestra en los mensajes de este Codelab.
Usar 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. Simula una red Thread
La aplicación de ejemplo que usarás en este Codelab demuestra una aplicación mínima de OpenThread que expone la configuración y las interfaces de administración de OpenThread a través de una interfaz de línea de comandos (CLI).
Este ejercicio te llevará por los pasos mínimos necesarios para hacer ping a un dispositivo Thread emulado desde otro dispositivo Thread emulado.
En la siguiente figura, se describe una topología básica de red de Thread. Para este ejercicio, emularemos los dos nodos dentro del círculo verde: un líder de subprocesos y un router de subprocesos con una sola conexión entre ellos.
Crea la red
1. Iniciar Node 1
Si aún no lo ha hecho, en una ventana de terminal, inicie el contenedor de Docker y conéctese 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 cargas útiles de UDP).
El argumento de 1
es un descriptor de archivo que representa los bits menos significativos de IEEE EUI-64 para el dispositivo emulado. Este valor también se usa cuando se realiza una vinculación 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 archivos diferente.
Nota: Solo usa descriptores de archivos de 1
o superior como se indica en este Codelab cuando generes el proceso para un dispositivo emulado. Un descriptor de archivos de 0
está reservado para otro uso.
Crear un nuevo conjunto de datos operativo y confirmarlo como 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
Abre la interfaz de IPv6:
> ifconfig up Done
Inicia la operación del protocolo Thread:
> thread start Done
Espera unos segundos y verifica que el dispositivo se haya convertido en el líder de subprocesos. El líder es el dispositivo responsable de administrar la asignación de ID de router.
> state leader Done
Visualiza las direcciones IPv6 asignadas a la interfaz de Thread del nodo 1 (tu 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
= malla local - Comienza con
fe80
= local-vínculo
Los tipos de dirección locales en malla se clasifican aún más:
- Contiene
ff:fe00
= Localizador de router (RLOC) - No contiene
ff:fe00
= Identificador de extremo (EID)
Identifica el EID en el resultado de tu consola y anótalo 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. Iniciar Node 2
Abre una terminal nueva y ejecuta un shell bash
en el contenedor de Docker que se ejecuta actualmente para usarlo con el nodo 2.
$ docker exec -it codelab_otsim_ctnr bash
En este nuevo mensaje 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 PAN con los mismos valores que el conjunto de datos operativo del nodo 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Confirma este conjunto de datos como el activo:
> dataset commit active Done
Abre la interfaz de IPv6:
> ifconfig up Done
Inicia la operación del protocolo Thread:
> thread start Done
El dispositivo se inicializará como secundario. Un subproceso secundario es un dispositivo final, que es un dispositivo Thread que transmite y recibe tráfico de unidifusión solo con un dispositivo superior.
> state child Done
En dos minutos, deberías ver el cambio de estado de child
a router
. Un router de subprocesos es capaz de enrutar el tráfico entre dispositivos de subprocesos. También se la conoce como superior.
> state router Done
Verifica la red
Una manera sencilla de verificar la red en malla es mirar 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 de RLOC del dispositivo.
> rloc16 5800 Done
En el nodo 1, verifica la tabla de router para el RLOC16 del nodo 2. Primero, asegúrate de que el nodo 2 haya cambiado al estado del 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 del nodo 2 de 0x5800
se encuentra en la tabla, lo que confirma que está conectado a la malla.
2. Hacer 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 mensaje de la CLI de >
.
Prueba la red
Ahora que puedes hacer ping correctamente entre dos dispositivos Thread emulados, prueba la red en malla dejando un nodo sin conexión.
Regresa al nodo 1 y detén el subproceso:
> thread stop Done
Cambia a Node 2 y verifica el estado. En dos minutos, el Nodo 2 detecta que el líder (Nodo 1) está sin conexión, y deberías ver que la transición del Nodo 2 es el leader
de la red:
> state router Done ... > state leader Done
Una vez confirmada, detén el subproceso y el restablecimiento de la configuración de fábrica del nodo 2 antes de volver al mensaje de Docker bash
. Se realiza un restablecimiento de fábrica para garantizar que las credenciales de red de Thread que usamos en este ejercicio no se transfieran al siguiente ejercicio.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Es posible que debas presionar enter
varias veces para que devuelva el mensaje >
después de un comando factoryreset
. No salga 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. Autenticar nodos con puesta en marcha
En el ejercicio anterior, configuraste una red Thread con dos dispositivos simulados y conectividad verificada. Sin embargo, esto solo permite que el tráfico local IPv6 no autenticado pase entre dispositivos. Para enrutar el tráfico IPv6 global entre estos (y la Internet a través de un router de borde de Thread), se deben autenticar los nodos.
Para autenticarse, un dispositivo debe actuar como comisionado. El comisionado es el servidor de autenticación electo para los nuevos dispositivos Thread 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 subproceso actúa como Comisionado, el router de subprocesos como tal.
Docker
Para cada nodo (ventana de la terminal) en los ejercicios restantes, asegúrese de ejecutar el contenedor de Docker con la compilación de OpenThread. Si continúas del ejercicio anterior, deberías tener dos mensajes bash
dentro del mismo contenedor de Docker ya abiertos. De lo contrario, consulte el paso Solución de problemas de Docker o vuelva a realizar el ejercicio Simular una red 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
.
Cree un nuevo conjunto de datos operativo, confírmelo como el activo y, luego, inicie 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
Abre la interfaz de IPv6:
> ifconfig up Done
Inicia la operación del protocolo Thread:
> thread start Done
Espera unos segundos y verifica que el dispositivo se haya convertido en líder de Thread:
> state leader Done
2. Inicie el rol de comisionado
En el nodo 1, inicia la función de comisionado:
> commissioner start Done
Permitir que cualquier Unión (con el comodín *
) con la Credencial J01NME
se encargue en la red. Un Joiner es un dispositivo que agrega un administrador humano a una red Thread encargada.
> commissioner joiner add * J01NME Done
3. Inicie el rol de Unión
En una segunda ventana de la terminal, en el contenedor de Docker, generará 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, habilite la función de unión con la credencial de unión J01NME
.
> ifconfig up Done > joiner start J01NME Done
Espera unos segundos para recibir la confirmación...
Join success
Como Unión, el dispositivo (Nodo 2) se autenticó correctamente con el Comisionado (Nodo 1) y recibió las credenciales de la Red de subprocesos.
Ahora que el nodo 2 está autenticado, inicia el subproceso:
> thread start Done
4. Valida la autenticación de la red
Verifica el state
en el nodo 2 para validar que se haya unido a la red. En dos minutos, el nodo 2 pasa de child
a router
:
> state child Done ... > state router Done
5. Restablecer configuración
A fin de prepararte para el próximo 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 devuelva el mensaje >
después de un comando factoryreset
.
5. Cómo administrar la red con OpenThread Daemon
Para este ejercicio, simularemos una instancia de CLI (un solo dispositivo SoC Thread incorporado) y una instancia de radioprocesador (RCP).
ot-daemon
es un modo de la app de OpenThread Posix que usa un socket UNIX como entrada y salida para que se pueda ejecutar el núcleo de OpenThread como servicio. Un cliente puede comunicarse con este servicio si se conecta 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 que crea el dispositivo Thread.
Docker
Para cada nodo (ventana de la terminal) en este ejercicio, asegúrese 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 abiertos. De lo contrario, consulta el paso Solución de problemas de Docker.
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
ot-daemon
ot-ctl
instancia de CLI
1. Iniciar Node 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
.
Cree un nuevo conjunto de datos operativo, confírmelo como el activo y, luego, inicie 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
Abre la interfaz de IPv6:
> ifconfig up Done
Inicia la operación del protocolo Thread:
> thread start Done
Visualiza 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 Thread, una dirección es local de vínculo (fe80
) y tres son locales de malla (fd
). El EID es la dirección de malla local que no contiene ff:fe00
en la dirección. En este resultado de muestra, el EID es fd55:cf34:dea5:7994:460:872c:e807:c4ab
.
Identifica el EID específico del resultado de ipaddr
, que se usará para comunicarse con el nodo.
2. Iniciar ot-daemon
En la segunda ventana de la terminal, crea un nodo de dispositivo tun
y configura los 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 utiliza para la recepción y transmisión de paquetes en dispositivos virtuales. Si el dispositivo ya se creó, es posible que aparezca un error normal.
Inicia ot-daemon
para un nodo de RCP, al que llamaremos Node 2. Usa la marca detallada -v
para 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 el 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
Deje esta terminal abierta y ejecutándose en segundo plano. No ingresarás más comandos.
3. Use ot-ctl para unirse a la red
Aún no encargamos el Nodo 2 (el RCP de ot-daemon
) a ninguna red Thread. Aquí es donde ot-ctl
entra en juego. ot-ctl
usa la misma CLI que la app de CLI de OpenThread. Por lo tanto, puedes controlar los nodos ot-daemon
de la misma manera que los otros dispositivos de Thread simulados.
Abre una tercera ventana de la 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 la terminal para administrar el Nodo 2 (el nodo RCP) que iniciaste en la segunda ventana de la 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 a la unión específica:
> eui64 18b4300000000001 Done
En el Nodo 1 (primera ventana de la terminal), inicia el Comisionado y restringe la unión a ese eui64 únicamente:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
En la tercera ventana de la terminal, abra la interfaz de red del nodo 2 y únase a la red:
> ifconfig up Done > joiner start J01NME Done
Espera unos segundos para recibir la confirmación...
Join success
Como Unión, el RCP (Nodo 2) se autenticó correctamente con el Comisionado (Nodo 1) y recibió las credenciales de la Red de subprocesos.
Ahora, une el Node 2 a la red Thread (nuevamente, en la tercera ventana de la terminal):
> thread start Done
4. Valida la autenticación de la red
En la tercera terminal, verifica el state
en el nodo 2 para validar que se haya unido a la red. En 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, cierra ot-ctl
con el comando Ctrl+D o exit
y vuelve a la consola bash
del contenedor. Desde esta consola, haz ping al nodo 1 mediante su EID con el comando ping6
. Si la instancia de RCP ot-daemon
se unió correctamente a la red Thread y se está comunicando con ella, el ping tiene éxito:
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 salió del contenedor de Docker
bash
Mensajes: Es posible que debas verificar si se está ejecutando y reiniciar o volver a ingresar según sea necesario.
Para mostrar qué contenedores de Docker están en ejecución, 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 (en ejecución y 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 de 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
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 está en ejecución (se enumera en docker ps
), vuelve a conectarte al contenedor en cada terminal:
$ docker exec -it codelab_otsim_ctnr bash
&"Operación no permitida"
Si encuentras errores Operation not permitted
cuando creas nodos de OpenThread nuevos (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 permisos de administrador.
7. ¡Felicitaciones!
Simulaste correctamente tu primera red Thread con OpenThread. ¡Genial!
En este Codelab aprendiste a hacer lo siguiente:
- Inicia y administra el contenedor de Docker para la simulación de OpenThread
- Simula una red Thread
- Autentica los nodos de subprocesos
- Cómo administrar una red Thread con Daemon de OpenThread
Para obtener más información sobre Thread y OpenThread, consulta las siguientes referencias:
- Thread Primer en openthread.io
- Especificación de subprocesos
- Repositorio de GitHub de OpenThread
- Referencia de la CLI de OpenThread
- Compatibilidad adicional con Docker de OpenThread
O bien, intenta usar el router de borde de OpenThread en un contenedor de Docker.