1. Introduzione
Che cos'è Thread?
Thread è un protocollo di rete mesh wireless a basso consumo basato su IP che consente comunicazioni sicure tra dispositivi e cloud. Le reti Thread possono adattarsi alle modifiche della topologia per evitare errori a livello di singolo punto.
Che cos'è OpenThread?
OpenThread rilasciato da Google è un'implementazione open source di Thread®.
Che cos'è un router di confine OpenThread?
Il router di confine OpenThread (OTBR) rilasciato da Google è un'implementazione open source del router di confine Thread.
NAT64
NAT64 è un meccanismo che consente agli host nelle reti solo IPv6 di accedere alle risorse nelle reti IPv4. Il gateway NAT64 è un traduttore tra i protocolli IPv4 e i protocolli IPv6.
Il traduttore NAT64, come parte del router di confine OpenThread, supporta la traduzione dei protocolli TCP, UDP e ICMP (ICMPv6).
Cosa creerai
In questo codelab, configurerai un router di confine OpenThread e un dispositivo Thread, quindi abiliti e verificherai la comunicazione tra i dispositivi Thread e gli host IPv4 su internet tramite il router di confine OpenThread.
Obiettivi didattici
- Come creare un router di confine OpenThread con funzionalità NAT64.
- Come comunicare con host IPv4 da dispositivi finali Thread.
Che cosa ti serve
- Una workstation Linux, per la creazione e il flashing di un NCP Thread, l'interfaccia a riga di comando OpenThread e il test della connettività IPv4.
- Un Raspberry Pi 4 con 4 GB di RAM per il router di confine Thread. La tua workstation Linux deve essere raggiungibile tramite IPv4 da questo dispositivo.
- 2 schede Nordic Semiconductor nRF52840 DK.
La topologia di rete per questo codelab:
2. Configura il router di confine OpenThread
Segui il passaggio di configurazione OTBR del codelab Thread Border Router - Bidirectional IPv6 and DNS-Based Service Discovery per creare il router di confine OpenThread, con la seguente modifica:
In Crea e installa OTBR, devi indicare allo script di abilitare il traduttore NAT64 in OpenThread impostando la variabile di ambiente NAT64 su 1 e NAT64_SERVICE su openthread. Esegui questo comando prima di questo passaggio:
$ export NAT64=1 NAT64_SERVICE=openthread
Continua con il codelab Thread Border Router - Bidirectional IPv6 and DNS-Based Service Discovery come scritto. Dopo aver completato la procedura di creazione di una rete Thread, puoi verificare che il router di confine pubblichi un prefisso NAT64 con i comandi dell'interfaccia a riga di comando OpenThread.
Innanzitutto, assicurati che il nostro router di confine sia attivo e in funzione e che NAT64 sia abilitato sul router di confine:
$ sudo ot-ctl state leader Done $ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Active Translator: Active Done
Dovremmo essere in grado di vedere che OTBR sta agendo come leader Thread e che c'è un prefisso NAT64 (fd4c:9574:3720:2:0:0::/96 nel nostro caso) nei dati di rete Thread:
$ sudo ot-ctl netdata show Prefixes: fd4c:9574:3720:1::/64 paos low 0800 Routes: fd49:7770:7fc5:0::/64 s med 0800 fd4c:9574:3720:2:0:0::/96 sn low 0800 Services: 44970 01 41000500000e10 s 0800 44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800 Done
Il prefisso NAT64 verrà utilizzato dai dispositivi Thread durante la comunicazione con un host IPv4.
3. Configura il dispositivo finale Thread
Segui il passaggio FTD della configurazione di una rete Thread con le schede nRF52840 e il codelab OpenThread per creare e eseguire il flashing di un dispositivo finale dell'interfaccia a riga di comando nRF52840, con una modifica al passaggio seguente:
In Build e Flash, devi aggiungere -DOT_DNS_CLIENT=ON, -DOT_SRP_CLIENT=ON e -DOT_ECDSA=ON alla riga di comando quando chiami script/build:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON -DOT_DNS_CLIENT=ON -DOT_SRP_CLIENT=ON -DOT_ECDSA=ON
Continua con il corso Build a Thread network with nRF52840 boards and OpenThread codelab come scritto. Dopo il flashing del dispositivo finale con l'immagine dell'interfaccia a riga di comando, segui Thread Border Router - Bidirectional IPv6 Connectivity and DNS-Based Service Discovery per configurare il dispositivo finale Thread.
Attendi qualche secondo dopo aver configurato il dispositivo finale Thread e verifica se l'accesso alla rete Thread è riuscito. Dovresti riuscire a trovare un prefisso NAT64 dai dati di rete (fd4c:9574:3720:2:0:0::/96 nel nostro caso):
> netdata show Prefixes: fd4c:9574:3720:1::/64 paos low 0800 Routes: fd49:7770:7fc5:0::/64 s med 0800 fd4c:9574:3720:2:0:0::/96 sn low 0800 Services: 44970 01 41000500000e10 s 0800 44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800 Done
Assicurati che i dati di rete corrispondano a quelli di OTBR.
4. Comunicazione con host IPv4 dal dispositivo finale Thread
Ora puoi comunicare con gli host sulla rete IPv4 dal dispositivo finale che abbiamo appena configurato.
Invia richieste echo ICMP agli host IPv4
Dall'interfaccia a riga di comando del nostro dispositivo finale Thread:
> ping 8.8.8.8 Pinging synthesized IPv6 address: fd4c:9574:3720:2:0:0:808:808 16 bytes from fd4c:9574:3720:2:0:0:808:808: icmp_seq=15 hlim=119 time=48ms 1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 48/48.0/48 ms. Done
Il router di confine crea un elemento mappatura NAT64 per questo dispositivo mediante il comando nat64 mappings:
$ sudo ot-ctl nat64 mappings | | Address | | 4 to 6 | 6 to 4 | +------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+ | ID | IPv6 | IPv4 | Expiry | Pkts | Bytes | Pkts | Bytes | +------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+ | 377ee63dd3127f1a | fd4c:9574:3720:1:1d61:b4c1:494f:f975 | 192.168.255.254 | 7190s | 1 | 16 | 1 | 16 | | | TCP | 0 | 0 | 0 | 0 | | | UDP | 0 | 0 | 0 | 0 | | | ICMP | 1 | 16 | 1 | 16 | Done
fd4c:9574:3720:1:1d61:b4c1:494f:f975 deve essere l'indirizzo IPv6 del tuo dispositivo Thread.
Esegui questo comando sul router di confine in qualsiasi momento per vedere come conteggia il traffico.
Invia query DNS ai server DNS IPv4
Utilizza dns resolve4 per risolvere un nome host sulla rete IPv4. L'indirizzo del server DNS può anche essere un indirizzo IPv4:
> dns resolve4 example.com 8.8.8.8 Synthesized IPv6 DNS server address: fd4c:9574:3720:2:0:0:808:808 DNS response for example.com. - fd4c:9574:3720:2:0:0:5db8:d822 TTL:20456 Done
Comunicare tramite TCP
È possibile stabilire connessioni TCP tra il dispositivo finale e gli host nella rete IPv4.
Supponiamo che l'indirizzo IP dell'host IPv4 Linux sia 192.168.0.2.
Sul tuo host IPv4 Linux, utilizza nc per ascoltare le connessioni TCP:
$ nc -l 0.0.0.0 12345
Dal dispositivo finale Thread, stabilisci una connessione TCP e invia messaggi al tuo host IPv4 Linux:
> tcp init Done > tcp connect 192.168.0.2 12345 Connecting to synthesized IPv6 address: fd4c:9574:3720:2:0:0:c0a8:2 Done > tcp send hello
Il tuo host IPv4 Linux restituisce:
hello
Puoi anche inviare messaggi dal tuo host IPv4 Linux al dispositivo finale Thread. Digita "mondo" e premi Invio sull'host IPv4 Linux che esegue nc e il dispositivo finale Thread restituirà:
TCP: Received 6 bytes: world
Comunicare tramite UDP
È possibile comunicare tramite UDP tra dispositivi Thread e host nella rete IPv4.
Supponiamo che l'indirizzo IP dell'host IPv4 Linux sia 192.168.0.2.
Utilizza nc per ascoltare le connessioni UDP:
$ nc -u -l 0.0.0.0 12345
Dal dispositivo finale Thread, stabilisci una connessione UDP e invia messaggi al tuo host IPv4 Linux:
> udp open Done > udp connect 192.168.0.2 12345 Connecting to synthesized IPv6 address: fd4c:9574:3720:2:0:0:c0a8:2 Done > udp send hello Done
Il tuo host IPv4 Linux restituisce:
hello
Puoi anche inviare messaggi dal tuo host IPv4 Linux al dispositivo finale Thread. Digita "mondo" e premi Invio sull'host IPv4 Linux che esegue nc e il dispositivo finale Thread restituirà:
6 bytes from fd4c:9574:3720:2:0:0:c0a8:2 12345 world
5. Attiva/disattiva NAT64 sul router di confine
Puoi abilitare o disabilitare NAT64 in qualsiasi momento. Usa nat64 disable per disabilitare NAT64. E usa nat64 state per controllare lo stato di NAT64.
$ sudo ot-ctl nat64 disable Done $ sudo ot-ctl nat64 state PrefixManager: Disabled Translator: Disabled Done
Dopo la disattivazione, il dispositivo non pubblica più un prefisso NAT64:
$ sudo ot-ctl netdata show Prefixes: fd4c:9574:3720:1::/64 paos low 0800 Routes: fd49:7770:7fc5:0::/64 s med 0800 Services: 44970 01 41000500000e10 s 0800 44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800 Done
Inoltre, i dispositivi nella rete Thread non possono più accedere all'host IPv4 tramite questo router di confine.
Dall'interfaccia a riga di comando del nostro dispositivo finale Thread:
> ping 8.8.8.8 Error 13: InvalidState
Usa nat64 enable per abilitare NAT64. Potrebbe essere necessario attendere un po' di tempo prima che il gestore prefissi inizi a pubblicizzare un prefisso NAT64:
$ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Idle Translator: NotWorking Done
Dopo alcuni secondi, i componenti NAT64 dovrebbero essere pronti e in esecuzione:
$ sudo ot-ctl nat64 state PrefixManager: Active Translator: Active Done $ sudo ot-ctl netdata show Prefixes: fd4c:9574:3720:1::/64 paos low 0800 Routes: fd49:7770:7fc5:0::/64 s med 0800 fd4c:9574:3720:2:0:0::/96 sn low 0800 Services: 44970 01 41000500000e10 s 0800 44970 5d fdd20e532b87b93f50ad4eea0450f1bfd11f s 0800 Done
Tieni presente che la disabilitazione di NAT64 cancellerà la tabella di mappatura:
$ sudo ot-ctl nat64 mappings | | Address | | 4 to 6 | 6 to 4 | +------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+ | ID | IPv6 | IPv4 | Expiry | Pkts | Bytes | Pkts | Bytes | +------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+ Done
6. Inoltra le query DNS ai server DNS upstream
Quando NAT64 è abilitato sul router di confine, OpenThread proverà a inoltrare le query DNS per i domini internet ai server DNS upstream.
Questa funzione è supportata dal server DNS-SD interno, quindi devi assicurarti che il server DNS-SD sia abilitato.
$ sudo ot-ctl srp server state running Done
Se non è running, abilitalo:
$ sudo ot-ctl srp server enable Done
Assicurati che il proxy DNS upstream sia abilitato:
$ sudo ot-ctl dns server upstream Enabled Done
Se non è Enabled, abilitalo:
$ sudo ot-ctl dns server upstream enable Done
Sui dispositivi finali, assicurati che il client SRP sia abilitato, in modo che invii le query DNS al router di confine:
> srp client state Enabled Done
Se non è Enabled, abilitalo:
> srp client autostart enable Done
Sul dispositivo finale, assicurati che il server DNS predefinito sia il router di confine:
> dns config Server: [fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf]:53 ResponseTimeout: 6000 ms MaxTxAttempts: 3 RecursionDesired: yes Done
L'indirizzo IPv6 del server (fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf nell'esempio precedente) deve essere uno degli indirizzi del tuo router di confine OpenThread.
Ora puoi inviare query DNS per i domini internet dal dispositivo finale:
> dns resolve example.com DNS response for example.com. - 2606:2800:220:1:248:1893:25c8:1946 TTL:8720 Done > dns resolve4 example.com DNS response for example.com. - fd4c:9574:3720:2:0:0:5db8:d822 TTL:20456 Done
7. Complimenti
Congratulazioni, hai configurato correttamente un router di confine con supporto NAT64 e lo hai utilizzato per fornire accesso a internet ai dispositivi finali Thread.
Per approfondire
- Guide di OpenThread
- Riferimento per l'interfaccia a riga di comando OpenThread
- Riferimento API OpenThread per NAT64
- Riferimento API OpenThread per DNS upstream
- Astrazione della piattaforma OpenThread per DNS