1. Introduzione
OpenThread rilasciato da Google è un'implementazione open source del protocollo di networking Thread. Google Nest ha rilasciato OpenThread per rendere disponibile agli sviluppatori la tecnologia utilizzata nei prodotti Nest per accelerare lo sviluppo dei prodotti per la casa connessa.
La specifica Thread definisce un protocollo di comunicazione da dispositivo a dispositivo wireless affidabile, sicuro e a basso consumo per le applicazioni domestiche. OpenThread implementa tutti i livelli di networking Thread, tra cui IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, mesh Link Establishment e Mesh Routing.
Questo codelab ti guiderà in una procedura di simulazione di una rete Thread sui dispositivi emulati utilizzando Docker.
Obiettivi didattici
- Come configurare la catena di strumenti di compilazione OpenThread
- Come simulare una rete Thread
- Come autenticare i nodi Thread
- Come gestire una rete Thread con OpenThread Daemon
Che cosa ti serve
- Docker
- Conoscenza di base di Linux, routing di rete
2. Configura Docker
Questo codelab è progettato per l'uso di Docker su macchine Linux, Mac OS X o Windows. Linux è l'ambiente consigliato.
Installa Docker
Installa Docker sul sistema operativo che preferisci.
Esegui il pull dell'immagine Docker
Una volta installato Docker, apri una finestra del terminale ed esegui il pull dell'immagine Docker openthread/environment. Questa immagine presenta OpenThread e OpenThread Daemon preconfigurati e pronti per essere utilizzati per questo codelab.
$ docker pull openthread/environment:latest
Tieni presente che il download potrebbe richiedere alcuni minuti.
In una finestra del terminale, avvia un container 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/environment bash
L'opzione --rm elimina il contenitore quando esci dal contenitore. Non utilizzare questa opzione se non vuoi che il contenitore venga eliminato.
Nota i flag richiesti per questo codelab:
--sysctl net.ipv6.conf.all.disable_ipv6=0: abilita IPv6 all'interno del container--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, dovrebbe essere visualizzata una richiesta simile alla seguente:
root@c0f3912a74ff:/#
Nell'esempio precedente, c0f3912a74ff è l'ID contenitore. L'ID container per la tua istanza del container Docker sarà diverso da quello mostrato nelle richieste per questo codelab.
Utilizzo di Docker
Questo codelab presuppone di conoscere le nozioni di base sull'utilizzo di Docker. Dovresti rimanere nel container Docker per tutto il codelab.
3. Simulare una rete Thread
L'applicazione di esempio che utilizzerai per questo codelab mostra un'applicazione OpenThread minima che espone le interfacce di configurazione e gestione di OpenThread tramite un'interfaccia a riga di comando (CLI) di base.
Questo esercizio ti mostrerà i passaggi minimi necessari per inviare un ping a un dispositivo Thread emulato da un altro dispositivo Thread emulato.
La figura seguente descrive una topologia di rete di Thread di base. Per questo esercizio, emuleremo i due nodi all'interno del cerchio verde: un leader del thread e un router Thread con una singola connessione tra loro.
Crea la rete
1. Avvia nodo 1
Se non lo hai già fatto, in una finestra del terminale avvia il container 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/environment bash
Nel container Docker, genera il processo dell'interfaccia a riga di comando per un dispositivo Thread emulato utilizzando il programma binario ot-cli-ftd.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.
Questo programma binario implementa un dispositivo OpenThread. 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 dello standard IEEE EUI-64 "assegnato in fabbrica" per il dispositivo emulato. Questo valore viene utilizzato anche quando si esegue il collegamento a una porta UDP per l'emulazione della radio IEEE 802.15.4 (porta = 9000 + descrittore del file). Ogni istanza di un dispositivo Thread emulato in questo codelab utilizzerà un descrittore di file diverso.
Nota: utilizza i descrittori dei file 1 o superiori come indicato in questo codelab per generare il processo per un dispositivo emulato. Un descrittore di file 0 è riservato a un altro utilizzo.
Creare un nuovo set di dati operativo e eseguirne il commit come attivo. Il set di dati operativi è la configurazione per la rete 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 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Esegui il commit di questo set di dati come attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia il funzionamento 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 degli ID router.
> state leader Done
Visualizza gli indirizzi IPv6 assegnati all'interfaccia Thread del nodo 1 (l'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
Osserva i tipi di indirizzo IPv6 specifici:
- Inizia con
fd= mesh-local - Inizia con
fe80= link-local
I tipi di indirizzo mesh locale sono classificati ulteriormente:
- Contiene
ff:fe00= Localizzatore router (RLOC) - Non contiene
ff:fe00= identificatore endpoint (EID)
Identifica l'EID nell'output della console e prendine nota per un uso futuro. Nell'output di esempio riportato sopra, l'EID è:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Avvia nodo 2
Apri un nuovo terminale ed esegui una shell bash nel container Docker attualmente in esecuzione da utilizzare per il nodo 2.
$ docker exec -it codelab_otsim_ctnr bash
Al nuovo prompt bash, genera il processo dell'interfaccia a riga di comando con l'argomento 2. Questo è il secondo dispositivo Thread emulato:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.
Configura la chiave di rete Thread e l'ID PAN utilizzando gli stessi valori del set di dati operativi del nodo 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Esegui il commit di questo set di dati come attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia il funzionamento del protocollo Thread:
> thread start Done
Il dispositivo si inizializza come bambino. Un asset secondario Thread è equivalente a un dispositivo finale, ovvero un dispositivo Thread che trasmette e riceve traffico comunicativo solo con un dispositivo principale.
> state child Done
Entro 2 minuti dovresti vedere il passaggio dello stato da child a router. Un router Thread è in grado di instradare il traffico tra dispositivi Thread. È anche indicato come Genitore.
> state router Done
Verifica la rete
Un modo semplice per verificare la rete mesh è controllare la tabella dei router.
1. Controlla connettività
Sul nodo 2, recupera RLOC16. RLOC16 è gli ultimi 16 bit dell'indirizzo RLOC IPv6 del dispositivo.
> rloc16 5800 Done
Sul nodo 1, controlla la tabella del router per il 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 |
La tabella RLOC di 0x5800 del nodo 2 si trova nella tabella e conferma che è connessa al mesh.
2. Ping del nodo 1 del nodo 2
Verifica la connettività tra i due dispositivi Thread emulati. Nel nodo 2, ping l'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
Premi enter per tornare alla richiesta dell'interfaccia a riga di comando di >.
Testa la rete
Ora che puoi inviare un ping tra due dispositivi Thread emulati, testa la rete mesh portando un nodo offline.
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 che la transizione del nodo 2 è il leader della rete:
> state router Done ... > state leader Done
Una volta confermato, arresta Thread e ripristina i dati di fabbrica del nodo 2 prima di tornare alla richiesta Docker di bash. Viene eseguito un ripristino dei dati di fabbrica per garantire che le credenziali di rete di Thread utilizzate in questo esercizio non vengano trasferite all'esercizio successivo.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Potresti dover premere enter volte alcune volte per ripristinare il messaggio > dopo un comando factoryreset. Non uscire dal container Docker.
Ripristina anche i dati di fabbrica e esci dal nodo 1:
> factoryreset > > exit root@c0f3912a74ff:/#
Consulta la pagina Riferimento interfaccia a riga di comando OpenThread per esplorare tutti i comandi dell'interfaccia a riga di comando disponibili.
4. Autenticare i nodi con la messa in servizio
Nell'esercizio precedente hai configurato una rete Thread con due dispositivi simulati e connettività verificata. Tuttavia, questo consente solo il passaggio tra traffico locale e link IPv6 non autenticato tra dispositivi. Per instradare il traffico IPv6 globale tra loro (e Internet tramite un router di confine Thread), i nodi devono essere autenticati.
Per eseguire l'autenticazione, un dispositivo deve agire da commissario. Il commissario è il server di autenticazione attualmente eletto per i nuovi dispositivi Thread e l'autorizzatore a fornire le credenziali di rete necessarie ai dispositivi per collegarsi alla rete.
In questo esercizio utilizzeremo la stessa topologia a due nodi di prima. Per l'autenticazione, il leader di Thread agisce in qualità di commissario, come router Thread come Joiner.
Docker
Per ogni nodo (finestra del terminale) negli esercizi rimanenti, assicurati di eseguire il container Docker con la build OpenThread. Se continui dall'esercizio precedente, dovresti avere ancora due richieste bash all'interno dello stesso container Docker già aperte. In caso contrario, consulta il passaggio Risoluzione dei problemi con Docker o ripeti l'esercizio Simula una rete Thread.
1. Crea una rete
Nel nodo 1, genera il processo dell'interfaccia a riga di comando:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.
Crea un nuovo set di dati operativo, eseguilo come attivo e avvia 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 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
Esegui il commit di questo set di dati come attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia il funzionamento del protocollo Thread:
> thread start Done
Attendi qualche secondo e verifica che il dispositivo sia diventato Thread Leader:
> state leader Done
2. Avviare il ruolo Commissario
Mentre sei ancora sul nodo 1, avvia il ruolo Commissioner:
> commissioner start Done
Consenti a qualsiasi Joiner (utilizzando il carattere jolly *) con la credenziale Joiner J01NME di effettuare commissioni sulla rete. Un joiner è un dispositivo che viene aggiunto da un amministratore a una rete Thread commissionata.
> commissioner joiner add * J01NME Done
3. Avvia il ruolo Collaboratore
In una seconda finestra del terminale, nel container Docker, genera un nuovo processo dell'interfaccia a riga di comando. Questo è il nodo 2.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
Sul nodo 2, abilita il ruolo Joiner utilizzando la credenziale di join J01NME.
> ifconfig up Done > joiner start J01NME Done
... attendi qualche secondo per la conferma ...
Join success
In qualità di falegname, il dispositivo (nodo 2) si è autenticato correttamente con il commissario (nodo 1) e ha ricevuto le credenziali di rete Thread.
Ora che il nodo 2 è autenticato, avvia Thread:
> thread start Done
4. Convalida l'autenticazione della rete
Controlla il state sul nodo 2, per verificare che sia stato aggiunto alla rete. Entro due minuti, le transizioni del nodo 2 da child a router:
> state child Done ... > state router Done
5. Reimposta configurazione
Per prepararti al prossimo esercizio, reimposta la configurazione. Su ciascun nodo, interrompi Thread, esegui un ripristino dei dati di fabbrica ed esci dal dispositivo Thread emulato:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
Potresti dover premere enter volte alcune volte per ripristinare il messaggio > dopo un comando factoryreset.
5. Gestire la rete con OpenThread Daemon
Per questo esercizio, simuleremo un'istanza dell'interfaccia a riga di comando (un unico dispositivo Thread SoC incorporato) e un'istanza di radio coprocessore (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 l'interfaccia a riga di comando OpenThread come protocollo.
ot-ctl è un'interfaccia a riga di comando fornita da ot-daemon per gestire e configurare l'RCP. In questo modo, collegheremo l'RCP alla rete creata dal dispositivo Thread.
Docker
Per ogni nodo (finestra del terminale) in questo esercizio, assicurati di eseguire il container Docker con la build OpenThread. Se continui dall'esercizio precedente, dovresti avere due richieste bash all'interno dello stesso container Docker già aperte. In caso contrario, consulta la sezione Risoluzione dei problemi con Docker.
Utilizza ot-daemon
Questo esercizio utilizzerà tre finestre del terminale, corrispondenti alle seguenti:
- Istanza CLI di dispositivo Thread simulato (Nodo 1)
- Processo
ot-daemon ot-ctlistanza dell'interfaccia a riga di comando
1. Avvia nodo 1
Nella prima finestra del terminale, genera il processo dell'interfaccia a riga di comando per il dispositivo Thread emulato:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
Nota: se non vedi il messaggio > dopo aver eseguito questo comando, premi enter.
Crea un nuovo set di dati operativo, eseguilo come attivo e avvia 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 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
Esegui il commit di questo set di dati come attivo:
> dataset commit active Done
Visualizza l'interfaccia IPv6:
> ifconfig up Done
Avvia il funzionamento 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 Simulare una rete Thread, un indirizzo deve essere locale rispetto al collegamento (fe80) e tre sono locale rispetto al mesh (fd). L'EID è l'indirizzo locale mesh 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 del tuo output ipaddr, che verrà utilizzato per comunicare con il nodo.
2. Avvia ot-daemon
Nella seconda finestra del terminale, crea un nodo dispositivo tun e imposta le autorizzazioni 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 dei pacchetti su dispositivi virtuali. Potresti visualizzare un errore se il dispositivo è già stato creato: si tratta di un comportamento normale che può essere ignorato.
Avvia ot-daemon per un nodo RCP, chiamato Nodo 2. Utilizza il flag con dettaglio -v per poter vedere l'output del log e verificare che sia in esecuzione:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \ 'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'
Se l'operazione ha esito positivo, ot-daemon in modalità dettagliata genera un output simile al seguente:
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
Lascia questo terminale aperto e in esecuzione in background. Non inserirai altri comandi al suo interno.
3. Utilizza OTT per accedere alla rete
Il nodo 2 (RCP ot-daemon) non è stato ancora commissionato a nessuna rete Thread. È qui che entra in gioco ot-ctl. ot-ctl utilizza lo stesso interfaccia a riga di comando dell'app OpenThread CLI. Pertanto, puoi controllare i nodi ot-daemon nello stesso modo degli altri dispositivi Thread simulati.
Apri una terza finestra di terminale ed esegui il container esistente:
$ docker exec -it codelab_otsim_ctnr bash
Una volta nel contenitore, avvia ot-ctl:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
Utilizzerai ot-ctl in questa terza finestra del terminale per gestire il nodo 2 (il nodo RCP) avviato nella seconda finestra del terminale con ot-daemon. Controlla il state del nodo 2:
> state disabled Done
Recupera il eui64 di nodo 2, per limitare l'unione al sottoscrittore specifico:
> eui64 18b4300000000001 Done
Sul Nodo 1 (prima finestra del terminale), avvia il Commissioner e limita l'unione solo a quella eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Nella terza finestra del terminale, apri l'interfaccia di rete per il Nodo 2 ed entra nella 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 correttamente con il Commissario (Nodo 1) e ha ricevuto le credenziali di Thread Network.
Ora unisci il nodo 2 alla rete Thread (di nuovo, nella terza finestra del terminale):
> thread start Done
4. Convalida l'autenticazione della rete
Nel terzo terminale, controlla il state sul nodo 2, per verificare che ora sia collegato alla rete. Entro due minuti, le transizioni del nodo 2 da child a router:
> state child Done ... > state router Done
5. Convalida connettività
Nella terza finestra del terminale, esci da ot-ctl utilizzando il comando Ctrl+D o exit e torna alla console bash del contenitore. Da questa console, invia un ping al nodo 1, utilizzando il relativo EID con il comando ping6. Se l'istanza ot-daemon RCP è collegata e comunica con la rete Thread, il ping riesce:
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. Risoluzione dei problemi relativi a Docker
Se sei uscito dal container Docker
bash richiedi: potrebbe essere necessario controllare se è in esecuzione e riavviare / riinserire se necessario. Tutti i container Docker che hai creato e per i quali non hai utilizzato l'opzione --rm continueranno a esistere.
Per vedere quali container Docker sono in esecuzione:
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Per visualizzare tutti i container Docker (sia in esecuzione che arrestati):
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
Se non vedi il container codelab_otsim_ctnr nell'output di uno dei comandi docker ps, eseguilo di nuovo:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
Utilizza l'opzione --rm solo se vuoi che il contenitore venga eliminato all'uscita dal contenitore.
Se il container viene arrestato (elencato in docker ps -a ma non in docker ps), riavvialo:
$ docker start -i codelab_otsim_ctnr
Se il container Docker è già in esecuzione (elencato in docker ps), ricollegalo al container in ogni terminale:
$ docker exec -it codelab_otsim_ctnr bash
Errori "Operazione non consentita"
Se riscontri errori di Operation not permitted durante la creazione di nuovi nodi OpenThread (utilizzando il comando mknod), assicurati di eseguire Docker come utente root in base ai comandi forniti in questo codelab. Questo codelab non supporta l'esecuzione di Docker in modalità rootless.
7. Complimenti.
Hai simulato correttamente la tua prima rete Thread utilizzando OpenThread. Ottimo!
In questo codelab hai imparato a:
- Avvia e gestisci il container Docker di simulazione OpenThread
- Simulare una rete Thread
- Autentica i nodi Thread
- Gestire una rete Thread con OpenThread Daemon
Per scoprire di più su Thread e OpenThread, consulta questi riferimenti:
- Thread Primer su openthread.io
- Specifica per i thread
- Repository GitHub di OpenThread
- Riferimento per l'interfaccia a riga di comando di OpenThread
- Supporto aggiuntivo di OpenThread Docker
In alternativa, prova a utilizzare il router di confine OpenThread in un container Docker.