Google is committed to advancing racial equity for Black communities. See how.
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Simulazione di una rete di thread utilizzando OpenThread in Docker

26b7f4f6b3ea0700.png

OpenThread rilasciato da Google è un'implementazione open source del protocollo di rete Thread . Google Nest ha rilasciato OpenThread per rendere la tecnologia utilizzata nei prodotti Nest ampiamente disponibile agli sviluppatori per accelerare lo sviluppo di prodotti per la casa connessa.

La specifica Thread definisce un protocollo di comunicazione da dispositivo a dispositivo wireless affidabile, sicuro ea basso consumo basato su IPv6 per applicazioni domestiche. OpenThread implementa tutti i livelli di rete Thread inclusi IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, Mesh Link Establishment e Mesh Routing.

Questo Codelab ti guiderà attraverso la simulazione di una rete Thread su dispositivi emulati utilizzando Docker.

Cosa imparerai

  • Come configurare la toolchain di build OpenThread
  • Come simulare una rete di thread
  • Come autenticare i nodi di thread
  • Come gestire una rete di thread con OpenThread Daemon

Di cosa avrai bisogno

  • Docker
  • Conoscenza di base di Linux, routing di rete

Questo Codelab è progettato per utilizzare Docker su una macchina Linux, Mac OS X o Windows. Linux è l'ambiente consigliato.

Installa Docker

Installa Docker sul sistema operativo di tua scelta.

Scarica Docker

Estrarre l'immagine Docker

Una volta installato Docker, apri una finestra di terminale ed openthread/codelab_otsim il openthread/codelab_otsim Docker openthread/codelab_otsim . Questa immagine presenta OpenThread e OpenThread Daemon pre-costruiti e pronti per l'uso per questo Codelab.

$ docker pull openthread/codelab_otsim:latest

Tieni presente che potrebbero essere necessari alcuni minuti per il download completo.

In una finestra di terminale, avvia un contenitore Docker dall'immagine e connettiti alla sua shell bash :

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/codelab_otsim bash

Nota i flag, che sono richiesti per questo Codelab:

  • --sysctl net.ipv6.conf.all.disable_ipv6=0 - abilita IPv6 all'interno del contenitore
  • --cap-add=net_admin - abilita la funzionalità NET_ADMIN, che consente di eseguire operazioni relative alla rete, come l'aggiunta di route IP

Una volta nel contenitore, dovresti avere un prompt simile a questo:

root@c0f3912a74ff:/#

Nell'esempio precedente, c0f3912a74ff è l'ID contenitore. L'ID del contenitore per l'istanza del contenitore Docker sarà diverso da quello mostrato nelle richieste di questo Codelab.

Utilizzando Docker

Questo Codelab presuppone che tu conosca le basi dell'utilizzo di Docker. Dovresti rimanere nel contenitore Docker per l'intero Codelab.

L'applicazione di esempio che utilizzerai per questo Codelab mostra un'applicazione OpenThread minima che espone le interfacce di gestione e configurazione OpenThread tramite un'interfaccia a riga di comando (CLI) di base.

Questo esercizio illustra i passaggi minimi necessari per eseguire il ping di un dispositivo Thread emulato da un altro dispositivo Thread emulato.

La figura seguente descrive una topologia di rete Thread di base. Per questo esercizio, emuleremo i due nodi all'interno del cerchio verde: un Thread Leader e un Thread Router con una singola connessione tra di loro.

6e3aa07675f902dc.png

Crea la rete

1. Avviare il nodo 1

Se non lo hai già fatto, in una finestra di terminale, avvia il contenitore Docker e connettiti alla sua shell bash :

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/codelab_otsim bash

Nel contenitore Docker, passare alla directory openthread e generare il processo CLI per un dispositivo Thread emulato utilizzando il binario ot-cli-ftd .

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Questo binario implementa un dispositivo OpenThread emulato sopra POSIX. Il driver radio IEEE 802.15.4 è implementato su UDP (i frame IEEE 802.15.4 vengono passati all'interno dei payload UDP).

L'argomento 1 è un descrittore di file che rappresenta i bit meno significativi dell'IEEE EUI-64 "assegnato in fabbrica" ​​per il dispositivo emulato. Questo valore viene utilizzato anche durante il collegamento a una porta UDP per l'emulazione radio IEEE 802.15.4 (porta = 9000 + descrittore di file). Ogni istanza di un dispositivo Thread emulato in questo Codelab utilizzerà un descrittore di file diverso.

Nota: utilizzare solo descrittori di file pari o superiori a 1 come indicato in questo Codelab quando si genera il processo per un dispositivo emulato. Un descrittore di file di 0 è riservato per altri usi.

Se non vedi il file

>

dopo aver eseguito questo comando, premere

enter

.

Crea un nuovo set di dati operativo e inseriscilo come attivo. Il set di dati operativi è la configurazione per la rete di thread che stai 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
Master Key: e4344ca17d1dca2a33f064992f31f786
Network Name: OpenThread-c169
PAN ID: 0xc169
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Salva questo set di dati come quello attivo:

> dataset commit active
Done

Visualizza l'interfaccia IPv6:

> ifconfig up
Done

Avvia l'operazione del protocollo Thread:

> thread start
Done

Attendi qualche secondo e verifica che il dispositivo sia diventato Thread Leader. Il Leader è il dispositivo responsabile della gestione dell'assegnazione dell'ID del router.

> state
leader
Done

Visualizza gli indirizzi IPv6 assegnati all'interfaccia Thread del nodo 1 (il tuo output sarà diverso):

> 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

Prendi nota dei tipi di indirizzo IPv6 specifici:

  • Inizia con fd = mesh-local
  • Inizia con fe80 = link-local

I tipi di indirizzi mesh locali sono classificati ulteriormente:

  • Contiene ff:fe00 = Router Locator (RLOC)
  • Non contiene ff:fe00 = Endpoint Identifier (EID)

Identificare l'EID nell'output della console e annotarlo per un uso successivo. Nell'output di esempio sopra, l'EID è:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. Avviare il nodo 2

Apri un nuovo terminale ed esegui una shell bash nel contenitore Docker attualmente in esecuzione da utilizzare per il nodo 2.

$ docker exec -it codelab_otsim_ctnr bash

A questo nuovo prompt di bash , accedere alla directory openthread e generare il processo CLI. Questo è il tuo secondo dispositivo Thread emulato:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

Se non vedi il file

>

prompt dopo aver eseguito questo comando, premere

enter

.

Configurare la chiave principale del thread e l'ID PAN, utilizzando gli stessi valori del set di dati operativi del nodo 1:

> dataset masterkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

Salva questo set di dati come quello attivo:

> dataset commit active
Done

Visualizza l'interfaccia IPv6:

> ifconfig up
Done

Avvia l'operazione del protocollo Thread:

> thread start
Done

Il dispositivo si inizializzerà come figlio. Un Thread Child è equivalente a un End Device, ovvero un dispositivo Thread che trasmette e riceve traffico unicast solo con un dispositivo Parent.

> state
child
Done

Entro 2 minuti dovresti vedere lo stato passare da child a router . Un router thread è in grado di instradare il traffico tra i dispositivi thread. Viene anche definito genitore.

> state
router
Done

Verifica la rete

Un modo semplice per verificare la rete mesh è guardare la tabella del router.

1. Verificare la connettività

Sul nodo 2, ottieni RLOC16. RLOC16 sono gli ultimi 16 bit dell'indirizzo RLOC IPv6 del dispositivo.

> rloc16
5800
Done

Sul nodo 1, controlla la tabella del router per RLOC16 del nodo 2. Assicurati che il nodo 2 sia passato prima allo stato 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 |

L'RLOC del nodo 2 di 0x5800 si trova nella tabella, confermando che è connesso alla mesh.

2. Eseguire il ping del nodo 1 dal nodo 2

Verificare la connettività tra i due dispositivi Thread emulati. Nel nodo 2, eseguire il ping dell'EID assegnato 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

Premere enter per tornare al prompt > CLI.

Testa la rete

Ora che puoi eseguire correttamente il ping tra due dispositivi Thread emulati, testa la rete mesh portando offline un nodo.

Torna al nodo 1 e interrompi il thread:

> thread stop
Done

Passa al nodo 2 e controlla lo stato. Entro due minuti, il nodo 2 rileva che il leader (Nodo 1) è offline e dovresti vedere la transizione del nodo 2 per essere il leader della rete:

> state
router
Done
...
> state
leader
Done

Una volta confermato, interrompere Thread e ripristinare le impostazioni di fabbrica del nodo 2 prima di tornare al prompt bash Docker. Viene eseguito un ripristino delle impostazioni di fabbrica per garantire che le credenziali di rete Thread utilizzate in questo esercizio non vengano trasferite all'esercizio successivo.

> thread stop
Done
> factoryreset
>
> exit
root@c0f3912a74ff:/#

Potrebbe essere necessario premere enter alcune volte per ripristinare il prompt > dopo un comando factoryreset . Non uscire dal contenitore Docker.

Ripristina anche le impostazioni di fabbrica ed esci dal nodo 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Vedere OpenThread CLI Reference per esplorare tutti i comandi CLI disponibili.

Nell'esercizio precedente, hai configurato una rete Thread con due dispositivi simulati e connettività verificata. Tuttavia, ciò consente solo il passaggio del traffico locale IPv6 non autenticato tra i dispositivi. Per instradare il traffico IPv6 globale tra di loro (e Internet tramite un router di confine thread), i nodi devono essere autenticati.

Per autenticarsi, un dispositivo deve fungere da Commissario. Il Commissario è il server di autenticazione attualmente eletto per i nuovi dispositivi Thread e l'autorizzazione per fornire le credenziali di rete necessarie affinché i dispositivi si colleghino alla rete.

In questo esercizio useremo la stessa topologia a due nodi di prima. Per l'autenticazione, il Thread Leader agirà come Commissioner, il Thread Router come Joiner.

d6a67e8a0d0b5dcb.png

Docker

Per ogni nodo (finestra del terminale) negli esercizi rimanenti, assicurati di eseguire il contenitore Docker con la build OpenThread. Se continui dall'esercizio precedente, dovresti comunque avere due prompt bash nello stesso contenitore Docker già aperto. In caso contrario, vedere il passaggio Risoluzione dei problemi di Docker o semplicemente ripetere l'esercizio Simulazione di una rete di thread .

1. Crea una rete

Nel nodo 1, genera il processo CLI:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Se non vedi il file

>

prompt dopo aver eseguito questo comando, premere

enter

.

Creare un nuovo set di dati operativi, eseguirne il commit come quello attivo e avviare il thread:

> 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
Master Key: a77fe1d03b0e8028a4e13213de38080e
Network Name: OpenThread-8f37
PAN ID: 0x8f37
PSKc: f9debbc1532487984b17f92cd55b21fc
Security Policy: 0, onrcb
Done

Salva questo set di dati come quello attivo:

> dataset commit active
Done

Visualizza l'interfaccia IPv6:

> ifconfig up
Done

Avvia l'operazione del protocollo Thread:

> thread start
Done

Attendi qualche secondo e verifica che il dispositivo sia diventato un Thread Leader:

> state
leader
Done

2. Inizia il ruolo di Commissario

Mentre sei ancora nel Nodo 1, inizia il ruolo di Commissario:

> commissioner start
Done

Consenti a qualsiasi Joiner (utilizzando il carattere jolly * ) con le credenziali di Joiner J01NME eseguire la commissione sulla rete. Un Joiner è un dispositivo che viene aggiunto da un amministratore umano a una rete di thread commissionata.

> commissioner joiner add * J01NME
Done

3. Avviare il ruolo di falegname

In una seconda finestra del terminale, nel contenitore Docker, genera un nuovo processo CLI. Questo è il nodo 2.

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 2

Sul nodo 2, abilita il ruolo Joiner utilizzando la credenziale Joiner J01NME .

> ifconfig up
Done
> joiner start J01NME
Done

... attendi qualche secondo per la conferma ...

Join success

In qualità di Joiner, il dispositivo (Nodo 2) si è autenticato con successo con il Commissioner (Nodo 1) e ha ricevuto le credenziali di Thread Network.

Ora che il nodo 2 è autenticato, avvia il thread:

> thread start
Done

4. Convalidare l'autenticazione di rete

Controllare lo state sul nodo 2, per verificare che ora sia entrato nella rete. Entro due minuti, il nodo 2 passa da child a router :

> state
child
Done
...
> state
router
Done

5. Ripristina la configurazione

Per prepararsi all'esercizio successivo, reimpostare la configurazione. In ogni nodo, interrompi Thread, ripristina le impostazioni di fabbrica ed esci dal dispositivo Thread emulato:

> thread stop
Done
> factoryreset
>
> exit
root@c0f3912a74ff:/#

Potrebbe essere necessario premere enter alcune volte per ripristinare il prompt > dopo un comando factoryreset .

Per questo esercizio, simuleremo un'istanza CLI (un singolo dispositivo SoC Thread incorporato) e un'istanza Radio Co-Processor (RCP).

ot-daemon è una modalità dell'app OpenThread Posix che utilizza un socket UNIX come input e output, in modo che il core OpenThread possa essere eseguito come servizio. Un client può comunicare con questo servizio connettendosi al socket utilizzando OpenThread CLI come protocollo.

ot-ctl è una CLI fornita da ot-daemon per gestire e configurare RCP. Usando questo, collegheremo l'RCP alla rete creata dal dispositivo Thread.

Docker

Per ogni nodo (finestra terminale) in questo esercizio, assicurati di eseguire il contenitore Docker con la build OpenThread. Se continui dall'esercizio precedente, dovresti avere due prompt bash nello stesso contenitore Docker già aperto. In caso contrario, vedere il passaggio Risoluzione dei problemi di Docker .

Usa ot-daemon

Questo esercizio utilizzerà tre finestre di terminale, corrispondenti alle seguenti:

  1. Istanza CLI del dispositivo Thread simulato (Nodo 1)
  2. processo ot-daemon
  3. istanza CLI ot-ctl

1. Avviare il nodo 1

Nella prima finestra del terminale, genera il processo CLI per il tuo dispositivo Thread emulato:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/simulation/bin/ot-cli-ftd 1

Se non vedi il file

>

dopo aver eseguito questo comando, premere

enter

.

Creare un nuovo set di dati operativi, eseguirne il commit come quello attivo e avviare il thread:

> 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
Master Key: ba6e886c7af50598df1115fa07658a83
Network Name: OpenThread-34e4
PAN ID: 0x34e4
PSKc: 38d6fd32c866927a4dfcc06d79ae1192
Security Policy: 0, onrcb
Done

Salva questo set di dati come quello attivo:

> dataset commit active
Done

Visualizza l'interfaccia IPv6:

> ifconfig up
Done

Avvia l'operazione del protocollo Thread:

> thread start
Done

Visualizza gli indirizzi IPv6 assegnati all'interfaccia 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
>

Come spiegato nel passaggio Simulate a Thread network , un indirizzo è link-local ( fe80 ) e tre sono mesh-local ( fd ). L'EID è l'indirizzo mesh locale che non contiene ff:fe00 nell'indirizzo. In questo output di esempio, l'EID è fd55:cf34:dea5:7994:460:872c:e807:c4ab .

Identifica l'EID specifico dall'output del tuo ipaddr , che verrà utilizzato per comunicare con il nodo.

2. Avvia ot-daemon

Nella seconda finestra del terminale, crea un nodo del dispositivo tun e imposta i permessi di lettura / scrittura:

root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200
root@c0f3912a74ff:/# chmod 600 /dev/net/tun

Questo dispositivo viene utilizzato per la trasmissione e la ricezione di pacchetti nei dispositivi virtuali. È possibile che venga visualizzato un errore se il dispositivo è già stato creato: ciò è normale e può essere ignorato.

Vai alla directory openthread e avvia ot-daemon per un nodo RCP, che chiameremo Nodo 2. Usa il flag -v verbose in modo da poter vedere l'output del log e confermare che è in esecuzione:

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-daemon -v \
    'spinel+hdlc+forkpty://output/simulation/bin/ot-rcp?forkpty-arg=2'

Quando ha successo, ot-daemon in modalità verbose genera un output simile al seguente:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun 7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun 7 2020 18:06:08

3. Usa ot-ctl per unirti alla rete

Non abbiamo ancora commissionato il Nodo 2 (l'RCP ot-daemon ) a nessuna rete Thread. Questo è dove ot-ctl entra. ot-ctl utilizza lo stesso CLI come l'applicazione OpenThread CLI. Pertanto, è possibile controllare i nodi ot-daemon allo stesso modo degli altri dispositivi Thread simulati.

Apri una terza finestra di terminale ed esegui il contenitore esistente:

$ docker exec -it codelab_otsim_ctnr bash

Una volta nel contenitore, avvia ot-ctl :

root@c0f3912a74ff:/# cd ~/src/openthread
root@c0f3912a74ff:/# ./output/posix/bin/ot-ctl
>

Controlla lo state del nodo 2 (il nodo RCP) che hai iniziato con ot-daemon :

> state
disabled
Done

Ottieni l' eui64 del Nodo 2, per limitare l'accesso allo specifico Joiner:

> eui64
18b4300000000001
Done

Sul nodo 1, avvia il Commissioner e limita l'adesione solo a quell'eui64:

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

Sul nodo 2, apri l'interfaccia di rete e unisciti alla rete:

> ifconfig up
Done
> joiner start J01NME
Done

... attendi qualche secondo per la conferma ...

Join success

In qualità di Joiner, l'RCP (Nodo 2) si è autenticato con successo con il Commissioner (Nodo 1) e ha ricevuto le credenziali di Thread Network.

Ora unisci il nodo 2 alla rete Thread:

> thread start
Done

4. Convalidare l'autenticazione di rete

Controllare lo state sul nodo 2, per verificare che ora sia entrato nella rete. Entro due minuti, il nodo 2 passa da child a router :

> state
child
Done
...
> state
router
Done

5. Convalidare la connettività

Esci da ot-ctl usando Ctrl + D e sulla riga di comando del tuo computer host, ping Nodo 1, usando il suo EID con il comando ping6 . Se l'istanza RCP del ot-daemon è unita e comunica con successo con la rete Thread, il ping ha esito positivo:

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

Se sei uscito dal Docker container

bash prompt, potrebbe essere necessario verificare se è in esecuzione e riavviare / Immettere nuovamente, se necessario.

Per mostrare quali container Docker sono in esecuzione:

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        codelab_otsim       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Per mostrare tutti i contenitori Docker (sia in esecuzione che arrestati):

$ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
505fc57ffc72        codelab_otsim       "bash"              10 minutes ago      Up 10 minutes                           codelab_otsim_ctnr

Se non vedi il contenitore codelab_otsim_ctnr nell'output di uno dei comandi docker ps , codelab_otsim_ctnr di nuovo:

$ docker run --name codelab_otsim_ctnr -it --rm \
   --sysctl net.ipv6.conf.all.disable_ipv6=0 \
   --cap-add=net_admin openthread/codelab_otsim bash

Se il contenitore viene arrestato (elencato in docker ps -a ma non docker ps ), riavviarlo:

$ docker start -i codelab_otsim_ctnr

Se il contenitore Docker è già in esecuzione (elencato in docker ps ), riconnettiti al contenitore in ogni terminale:

$ docker exec -it codelab_otsim_ctnr bash

Hai simulato con successo la tua prima rete di thread utilizzando OpenThread. Eccezionale!

In questo Codelab hai imparato come:

  • Avvia e gestisci il contenitore Docker di OpenThread Simulation
  • Simula una rete di thread
  • Autentica i nodi del thread
  • Gestisci una rete di thread con OpenThread Daemon

Per ulteriori informazioni su Thread e OpenThread, esplora questi riferimenti:

Oppure prova a utilizzare OpenThread Border Router in un container Docker !