Simulare una rete Thread utilizzando OpenThread in Docker

1. Introduzione

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 al fine di accelerare lo sviluppo di prodotti per la casa connessa.

La specifica Thread definisce un protocollo di comunicazione tra dispositivi wireless basato su IPv6 affidabile, sicuro e a basso consumo per le applicazioni domestiche. OpenThread implementa tutti i livelli di rete Thread inclusi IPv6, 6LoWPAN, IEEE 802.15.4 con sicurezza MAC, rete mesh e routing mesh.

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

Obiettivi didattici

  • Come configurare la toolchain di build OpenThread
  • Come simulare una rete Thread
  • Come autenticare i nodi Thread
  • Come gestire una rete Thread con il daemon OpenThread

Che cosa ti serve

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

2. Configura Docker

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

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 mostra il daemon OpenThread e OpenThread predefinito e pronto per l'uso per questo codelab.

$ docker pull openthread/environment:latest

Tieni presente che il download completo potrebbe richiedere alcuni minuti.

In una finestra del terminale, avvia un container Docker dall'immagine e connettiti alla rispettiva 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.

Osserva i flag, necessari per questo codelab:

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

Una volta nel container, dovresti visualizzare un prompt simile a questo:

root@c0f3912a74ff:/#

Nell'esempio precedente, c0f3912a74ff è l'ID contenitore. L'ID container della tua istanza del container Docker sarà diverso da quello mostrato nei prompt di questo codelab.

Utilizzo di Docker

Questo codelab presuppone che tu conosca le nozioni di base sull'utilizzo di Docker. Dovresti rimanere nel container Docker per tutto il codelab.

3. Simula una rete Thread

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

Questo esercizio illustra 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 base di rete Thread. 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.

6e3aa07675f902dc.png

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 rispettiva 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 file binario ot-cli-ftd.

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

Nota: se non vedi la richiesta > 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 di 1 è un descrittore di file che rappresenta i bit meno significativi del processo "assegnato dal fabbrica" IEEE EUI-64 per il dispositivo emulato. Questo valore viene utilizzato anche durante l'associazione 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: usa solo descrittori file di 1 o superiore, come indicato in questo codelab, quando crei il processo per un dispositivo emulato. Un descrittore del file 0 è riservato per altri utilizzi.

Creare un nuovo set di dati operativo ed eseguirne il commit come attivo. Il set di dati operativo è 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 l'operazione del protocollo Thread:

> thread start
Done

Attendi qualche secondo e verifica che il dispositivo abbia ottenuto il ruolo Thread Leader. Il leader è il dispositivo responsabile della gestione dell'assegnazione dell'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

Prendi nota dei tipi di indirizzi 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)

Identifica l'EID nell'output della console e annotalo per utilizzarlo in seguito. Nell'output di esempio precedente, 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

In questo nuovo prompt bash, genera il processo dell'interfaccia a riga di comando con l'argomento 2. Questo è il tuo secondo dispositivo Thread emulato:

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

Nota: se non vedi la richiesta > 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 operativo 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 l'operazione del protocollo Thread:

> thread start
Done

Il dispositivo si inizializza come account secondario. Un dispositivo Thread secondario equivale a un dispositivo finale, ovvero un dispositivo Thread che trasmette e riceve traffico unicast solo con un dispositivo principale.

> state
child
Done

Entro 2 minuti dovresti vedere il passaggio di stato da child a router. Un router Thread è in grado di instradare il traffico tra dispositivi Thread. È anche definito Genitore.

> state
router
Done

Verifica la rete

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

1. Controlla la connettività

Sul nodo 2, ottieni il RLOC16. RLOC16 corrisponde agli ultimi 16 bit dell'indirizzo IPv6 RLOC del dispositivo.

> rloc16
5800
Done

Sul nodo 1, controllare la tabella del router per il RLOC16 del nodo 2. Assicurati prima che il nodo 2 sia passato allo stato 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 di 0x5800 del nodo 2 è indicato nella tabella, a conferma che è connesso al mesh.

2. Esegui ping al nodo 1 dal 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 al prompt dell'interfaccia a riga di comando >.

Testa la rete

Ora che sei in grado di inviare un ping tra due dispositivi Thread emulati, testa la rete mesh mettendo 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 la leader (nodo 1) è offline e dovresti vedere la transizione del nodo 2 come leader della rete:

> state
router
Done
...
> state
leader
Done

Una volta confermato, arresta il thread e ripristina i dati di fabbrica del nodo 2 prima di tornare al prompt Docker bash. Viene eseguito un ripristino dei dati 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:/#

Potresti dover premere enter alcune volte per ripristinare il prompt > dopo un comando factoryreset. Non uscire dal container Docker.

Ripristina i dati di fabbrica ed esci dal nodo 1:

> factoryreset
>
> exit
root@c0f3912a74ff:/#

Consulta la documentazione sull'interfaccia a riga di comando OpenThread per esplorare tutti i comandi dell'interfaccia a riga di comando disponibili.

4. Autentica i nodi con Commissioning

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

Per l'autenticazione, un dispositivo deve fungere da Commissioner. Il Commissioner è il server di autenticazione attualmente eletto per i nuovi dispositivi Thread e l'autore dell'autorizzazione a fornire le credenziali di rete necessarie ai dispositivi per accedere alla rete.

In questo esercizio utilizzeremo la stessa topologia a due nodi di prima. Per l'autenticazione, il leader del Thread agirà come Commissioner, il router Thread come joiner.

d6a67e8a0d0b5dcb.png

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 prompt bash all'interno dello stesso container Docker già aperti. In caso contrario, vedi il passaggio Risoluzione dei problemi di Docker o ripeti semplicemente 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 la richiesta > dopo aver eseguito questo comando, premi enter.

Crea un nuovo set di dati operativo, eseguine il commit 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 l'operazione del protocollo Thread:

> thread start
Done

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

> state
leader
Done

2. Inizia il ruolo di Commissioner

Mentre sei ancora sul nodo 1, avvia il ruolo di Commissioner:

> commissioner start
Done

Consenti a qualsiasi Joiner (utilizzando il carattere jolly *) con la credenziale Joiner J01NME di effettuare la commissione 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 Joiner

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 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 correttamente con il Commissioner (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 di rete

Controlla state sul nodo 2 per verificare che sia ora connesso alla rete. Entro due minuti, il nodo 2 esegue la transizione da child a router:

> state
child
Done
...
> state
router
Done

5. Reimposta configurazione

Per prepararti all'esercizio successivo, reimposta la configurazione. Su ogni nodo, interrompi Thread, ripristina i dati di fabbrica ed esci dal dispositivo Thread emulato:

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

Potresti dover premere enter alcune volte per ripristinare il prompt > dopo un comando factoryreset.

5. Gestisci la rete con il daemon OpenThread

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 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 prompt bash all'interno dello stesso container Docker già aperti. In caso contrario, fai riferimento al passaggio Risoluzione dei problemi di Docker.

Utilizzare 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. ot-ctl istanza 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 tuo dispositivo Thread emulato:

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

Nota: se non vedi la richiesta > dopo aver eseguito questo comando, premi enter.

Crea un nuovo set di dati operativo, eseguine il commit 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 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 Simula una rete Thread, un indirizzo è locale rispetto al collegamento (fe80) e tre sono locali 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 nell'output 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 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 di pacchetti nei dispositivi virtuali. Se il dispositivo è già stato creato, è possibile che venga visualizzato un messaggio di errore. Questo è normale e può essere ignorato.

Avvia ot-daemon per un nodo RCP, che chiameremo Nodo 2. Usa il flag dettagliato -v in modo da poter visualizzare l'output del log e confermare che è 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 il terminale aperto e in esecuzione in background. Non inserirai altri comandi al suo interno.

3. Utilizza ot-ctl per connetterti alla rete

Non abbiamo ancora commissionato il nodo 2 (l'RCP di ot-daemon) a nessuna rete Thread. È qui che entra in gioco ot-ctl. ot-ctl utilizza la stessa interfaccia a riga di comando dell'app OpenThread CLI. Pertanto, puoi controllare ot-daemon nodi allo stesso modo degli altri dispositivi Thread simulati.

Apri una terza finestra del terminale ed esegui il container esistente:

$ docker exec -it codelab_otsim_ctnr bash

Una volta nel container, 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) che hai avviato nella seconda finestra del terminale con ot-daemon. Controlla il state del nodo 2:

> state
disabled
Done

Ottieni eui64 del nodo 2 per limitare l'unione al join 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, visualizza l'interfaccia di rete per il nodo 2 e unisciti alla rete:

> ifconfig up
Done
> joiner start J01NME
Done

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

Join success

Come Joiner, l'RCP (nodo 2) si è autenticato con successo con il Commissioner (nodo 1) e ha ricevuto le credenziali della rete Thread.

Ora unisci il nodo 2 alla rete Thread (di nuovo, nella terza finestra del terminale):

> thread start
Done

4. Convalida l'autenticazione di rete

Nel terzo terminale, controlla state sul nodo 2 per verificare che sia ora unito alla rete. Entro due minuti, il nodo 2 esegue la transizione da child a router:

> state
child
Done
...
> state
router
Done

5. Convalida la connettività

Nella terza finestra del terminale, esci da ot-ctl utilizzando il comando Ctrl+D o exit e torna alla console bash del container. Da questa console, invia un ping al nodo 1 utilizzando il relativo EID con il comando ping6. Se l'istanza RCP ot-daemon è connessa correttamente alla rete Thread e comunica 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

6. Risoluzione dei problemi Docker

Se esci dal container Docker

bash prompt, potresti dover controllare se è in esecuzione e riavviarlo / reinserirlo in base alle esigenze. Tutti i container Docker creati per i quali non hai utilizzato l'opzione --rm dovrebbero continuare a esistere.

Per mostrare i container Docker 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 (in esecuzione e 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 nessuno dei due 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 è stato 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), riconnettiti al container in ogni terminale:

$ docker exec -it codelab_otsim_ctnr bash

"Operazione non consentita" errori

Se si verificano errori 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 la tua prima rete Thread utilizzando OpenThread. Ottimo!

In questo codelab hai imparato a:

  • Avviare e gestire il container Docker di simulazione OpenThread
  • Simula una rete Thread
  • Autentica i nodi Thread
  • Gestire una rete Thread con il daemon OpenThread

Per scoprire di più su Thread e OpenThread, consulta questi riferimenti:

In alternativa, prova a utilizzare il router di confine OpenThread in un container Docker.