Se usó la API de Cloud Translation para traducir esta página.

Cómo simular una red Thread con OpenThread en Docker

1. Introducción

OpenThread, que lanzó Google, es una implementación de código abierto del protocolo de herramientas de redes de Thread. Google Nest lanzó OpenThread a fin de poner a disposición de los desarrolladores la tecnología que se usa en los productos Nest para acelerar el desarrollo de productos en el hogar conectado.

La especificación de Thread define un protocolo de comunicación entre dispositivos inalámbrico, confiable y seguro basado en IPv6 para las aplicaciones de la casa. OpenThread implementa todas las capas de red Thread, incluidas IPv6, 6LoWPAN, IEEE 802.15.4, con seguridad MAC, el establecimiento de vínculos de malla y el enrutamiento de mallas.

En este codelab, te guiaremos por la simulación de 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 de Thread con OpenThread Daemon

Requisitos

Docker
Conocimientos básicos 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 muestran OpenThread y OpenThread Daemon precompilados y listos para usarse en este Codelab.

$ docker pull openthread/environment:latest

Tenga 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 obligatorias 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 IP.

Una vez en el contenedor, deberías ver un mensaje similar al siguiente:

root@c0f3912a74ff:/#

En el ejemplo anterior, el c0f3912a74ff es el ID del contenedor. El ID de contenedor de tu instancia del contenedor de Docker será diferente del que se muestra en las indicaciones 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. Simular una red Thread

En la aplicación de ejemplo que usarás en este Codelab, se muestra una aplicación mínima de OpenThread que expone la interfaz de configuración y administración de OpenThread mediante una interfaz de línea de comandos (CLI) básica.

En este ejercicio, se explican 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. En este ejercicio, emularemos los dos nodos dentro del círculo verde: un líder del subproceso y un router de subprocesos con una sola conexión entre ellos.

Crea la red

1. Iniciar nodo 1

Si aún no lo hiciste, en una ventana de la 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 de un dispositivo Thread emulado mediante 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 archivos que representa los bits menos importantes de la IEEE EUI-64 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 archivos). 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 activo El conjunto de datos operativo es la configuración de la red Thread que está 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

Confirme este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz 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 del subproceso. El líder es el dispositivo responsable de administrar la asignación de ID del router.

> state
leader
Done

Consulta las direcciones IPv6 asignadas a la interfaz de Thread de Node 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

Observa los tipos de direcciones IPv6 específicos:

Comienza con fd = malla-local
Comienza con fe80 = link-local

Los tipos de direcciones locales de malla se clasifican con más detalle:

Contiene ff:fe00 = Localizador de routers (RLOC)
No contiene ff:fe00 = Identificador de extremo (EID)

Identifica el EID en el resultado de tu consola. Anota este dato 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 el nodo 2

Abre una terminal nueva y ejecuta un shell bash en el contenedor de Docker que se está ejecutando para usarlo en Node 2.

$ docker exec -it codelab_otsim_ctnr bash

En este mensaje de bash nuevo, 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 operativo del nodo 1:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Confirme este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

El dispositivo se inicializará como elemento secundario. Un elemento secundario de Thread es equivalente a un dispositivo final, que es un dispositivo de Thread que transmite y recibe tráfico de unidifusión solo con un dispositivo superior.

> state
child
Done

En 2 minutos, deberías ver el cambio de estado de child a router. Un router de Thread puede enrutar el tráfico entre dispositivos de Thread. También se lo conoce como padre.

> state
router
Done

Verifica la red

Una manera sencilla de verificar la red en malla es observar la tabla del router.

1. Comprueba 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, revisa la tabla del router de 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. Haz ping al nodo 1 desde el nodo 2

Verifica la conectividad entre los dos dispositivos Thread emulados. En el Nodo 2, ping es 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 y desconecta un nodo.

Regresa al nodo 1 y detén el subproceso:

> thread stop
Done

Cambia al Nodo 2 y verifica el estado. En dos minutos, el Nodo 2 detecta que el líder (Nodo 1) no tiene 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 que se confirme, detiene el subproceso y restablecimiento de la configuración de fábrica del nodo 2 antes de volver al mensaje bash de Docker. Se restablece la configuración 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 vuelva a aparecer 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 Node 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Consulta la referencia de la CLI de OpenThread para explorar todos los comandos de la CLI disponibles.

4. Autentica los nodos con comisiones

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 los dispositivos. Para enrutar el tráfico IPv6 global entre ellos (y a través de Internet a través de un router de borde de Thread), se deben autenticar los nodos.

A fin de autenticarse, un dispositivo debe actuar como Comisionado. El comisionado es el servidor de autenticación elegido actualmente para los nuevos dispositivos Thread y el autorizador para brindar 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, es decir, como router.

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úa desde el ejercicio anterior, debería tener dos mensajes bash en el mismo contenedor de Docker abiertos. De lo contrario, consulta el paso Solución de problemas de Docker o simplemente rehacer 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 operacional, confírmelo como el conjunto de datos activo y, luego, inicie la conversación.

> 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

Confirme este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz 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 del subproceso:

> state
leader
Done

2. Inicia la función de comisionado

En el nodo 1, inicia la función de comisionado:

> commissioner start
Done

Permitir cualquier unión (mediante el comodín *) con la credencial de unión J01NME para la asignación en la red Un Joiner es un dispositivo que agrega un administrador humano a una red Thread encargada por encargo.

> commissioner joiner add * J01NME
Done

3. Inicie la función de unión

En una segunda ventana de la terminal, en el contenedor de Docker, aparecerá un nuevo proceso de CLI. Es el Nodo 2.

root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2

En el Nodo 2, habilita la función de unión con la credencial de unión de J01NME.

> ifconfig up
Done
> joiner start J01NME
Done

... espere unos segundos para recibir la confirmación ...

Join success

Como Joiner, el dispositivo (Node 2) se autenticó correctamente con el Comisionado (Node 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 redes

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

Restablece la configuración a fin de prepararte para el próximo ejercicio. 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. Administrar la red con OpenThread Daemon

Para este ejercicio, simularemos una instancia de la CLI (un solo dispositivo con SoC Thread) 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 el núcleo de OpenThread se pueda ejecutar como servicio. Un cliente puede comunicarse con este servicio si se conecta al socket mediante 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 la terminal) en este ejercicio, asegúrese de ejecutar el contenedor de Docker con la compilación de OpenThread. Si continúa desde el ejercicio anterior, debería tener dos mensajes bash en el mismo contenedor de Docker abiertos. De lo contrario, consulta el paso Solución de problemas de Docker.

Usa ot-daemon

En este ejercicio, se usarán tres ventanas de terminal, que corresponden a lo siguiente:

Instancia de la CLI de un dispositivo Thread simulado (nodo 1)
Proceso ot-daemon
Instancia de la CLI de ot-ctl

1. Iniciar nodo 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 operacional, confírmelo como el conjunto de datos activo y, luego, inicie la conversación.

> 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

Confirme este conjunto de datos como el activo:

> dataset commit active
Done

Abre la interfaz IPv6:

> ifconfig up
Done

Inicia la operación del protocolo Thread:

> thread start
Done

Consulta las direcciones IPv6 asignadas a la interfaz de Thread 1's:

> 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 de vínculo local (fe80) y tres son locales (fd). El EID es la dirección de la 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 de tu 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 usa para la recepción y transmisión de paquetes en dispositivos virtuales. Si el dispositivo ya se creó, es posible que aparezca un error. Esto es normal y puedes ignorarlo.

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

Deje esta terminal abierta y en ejecución en segundo plano. No ingresarás más comandos.

3. Use ot-ctl para unirse a la red

Todavía no se encargó el nodo 2 (el RCP 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 demás dispositivos Thread simulados.

Abra una tercera ventana de la terminal y ejecute 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 al objeto Joiner específico:

> eui64
18b4300000000001
Done

En el Nodo 1 (primera ventana de la terminal), inicia el Comisionado y restringe la unión para que solo use ese eui64:

> commissioner start
Done
> commissioner joiner add 18b4300000000001 J01NME
Done

En la tercera ventana de la terminal, abra la interfaz de red correspondiente al Node 2 y una la red:

> ifconfig up
Done
> joiner start J01NME
Done

... espere unos segundos para recibir la confirmación ...

Join success

Como unión, el RCP (nodo 2) se autenticó correctamente en el comisionado (nodo 1) y recibió las credenciales de la red de Thread.

Ahora, une el nodo 2 a la red Thread (una vez más, en la tercera ventana de la terminal):

> thread start
Done

4. Valida la autenticación de redes

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 regresa a la consola de bash del contenedor. Desde esta consola, haz ping al nodo 1 mediante el EID con el comando ping6. Si la instancia de RCP ot-daemon se une correctamente a la red Thread y se comunica 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 se están ejecutando, haga 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):

$ 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 cualquiera 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

Si el contenedor está detenido (se enumera 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 (enumerado en docker ps), vuelve a conectarte al contenedor en cada terminal:

$ docker exec -it codelab_otsim_ctnr bash

Errores de operación no permitidos

Si encuentras errores Operation not permitted cuando creas nodos de OpenThread nuevos (con el comando mknod), asegúrate de ejecutar Docker como el usuario raíz según los comandos que se proporcionan en este Codelab. Este Codelab no admite ejecutar Docker en modo sin raíz.

7. ¡Felicitaciones!

Simulaste con éxito tu primera red Thread con OpenThread. ¡Genial!

En este Codelab aprendiste a hacer lo siguiente:

Inicie y administre el contenedor de Docker para la simulación de OpenThread
Simular una red Thread
Autentica los nodos de Thread
Cómo administrar una red de Thread con OpenThread Daemon

Para obtener más información sobre Thread y OpenThread, explora estas referencias:

O bien, intenta usar Router de borde de OpenThread en un contenedor de Docker.