1. Introduction
Qu'est-ce que Thread ?
Thread est un protocole de réseau maillé sans fil basse consommation basé sur l'adresse IP, qui permet des communications sécurisées d'appareil à appareil et d'appareil à cloud. Les réseaux Thread peuvent s'adapter aux changements de topologie pour éviter les défaillances à point unique.
Qu'est-ce qu'OpenThread ?
OpenThread publié par Google est une implémentation Open Source de Thread®.
Qu'est-ce qu'un routeur de bordure OpenThread ?
Le routeur de bordure OpenThread (OTBR) publié par Google est une implémentation Open Source du routeur de bordure Thread.
NAT64
NAT64 est un mécanisme qui permet aux hôtes des réseaux IPv6 uniquement d’accéder aux ressources des réseaux IPv4. La passerelle NAT64 est un traducteur entre les protocoles IPv4 et IPv6.
Le traducteur NAT64, qui fait partie du routeur de bordure OpenThread, prend en charge la traduction des protocoles TCP, UDP et ICMP (ICMPv6).
Ce que vous allez faire
Dans cet atelier de programmation, vous allez configurer un routeur de bordure OpenThread et un appareil Thread, puis activer et vérifier la communication entre les appareils Thread et les hôtes IPv4 sur Internet via un routeur de bordure OpenThread.
Points abordés
- Créer un routeur de bordure OpenThread avec les fonctionnalités NAT64
- Communication avec les hôtes IPv4 provenant d'appareils de fin Thread
Prérequis
- Une station de travail Linux, pour compiler et flasher un NCP Thread, la CLI OpenThread et tester la connectivité IPv4.
- Raspberry Pi 4 avec 4 Go de RAM pour le routeur de bordure Thread. Votre poste de travail Linux doit être accessible via IPv4 à partir de cet appareil.
- 2 cartes Nordic Semiconductor nRF52840 (DK).
Topologie du réseau pour cet atelier de programmation:
2. Configurer le routeur de bordure OpenThread
Suivez l'étape de configuration du protocole OTBR de l'atelier de programmation sur le routeur de bordure Thread - Connectivité IPv6 bidirectionnelle et découverte de services basés sur le DNS pour créer le routeur de bordure OpenThread, avec la modification suivante:
Dans Build and install OTBR (Compiler et installer OTBR), vous devez indiquer au script d'activer le traducteur NAT64 dans OpenThread en définissant la variable d'environnement NAT64 sur 1 et NAT64_SERVICE sur openthread. Exécutez la commande suivante avant cette étape:
$ export NAT64=1 NAT64_SERVICE=openthread
Poursuivez l'atelier de programmation Routeur de bordure Thread – Connectivité IPv6 bidirectionnelle et découverte de services basés sur le DNS tel qu'écrit. Après avoir formé un réseau Thread, vous pouvez vérifier que le routeur de bordure publie un préfixe NAT64 à l'aide des commandes CLI OpenThread.
Tout d'abord, assurez-vous que notre routeur de bordure est opérationnel et que NAT64 est activé sur celui-ci:
$ sudo ot-ctl state leader Done $ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Active Translator: Active Done
Nous devrions être en mesure de voir que OTBR agit en tant que leader de thread et qu'il y a un préfixe NAT64 (fd4c:9574:3720:2:0:0::/96 dans notre cas) dans les données réseau des threads:
$ 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
Le préfixe NAT64 sera utilisé par les appareils Thread lors de la communication avec un hôte IPv4.
3. Configurer l'appareil de fin Thread
Suivez l'étape Configurer les FTD de l'atelier de programmation Créer un réseau Thread avec des cartes nRF52840 et OpenThread pour créer et flasher un appareil de fin de CLI nRF52840, en modifiant l'étape suivante:
Dans Build and Flash, vous devez ajouter -DOT_DNS_CLIENT=ON, -DOT_SRP_CLIENT=ON et -DOT_ECDSA=ON à la ligne de commande lorsque vous appelez 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
Poursuivez l'atelier de programmation Créer un réseau Thread avec des cartes nRF52840 et OpenThread tel qu'écrit. Une fois que l'image de la CLI a été flashée sur l'appareil final, suivez les instructions de la page Routeur de bordure Thread – Connectivité IPv6 bidirectionnelle et découverte de services basés sur le DNS pour configurer l'appareil final Thread.
Attendez quelques secondes après avoir configuré l'appareil de fin Thread, puis vérifiez si vous parvenez à rejoindre le réseau Thread. Vous devriez trouver un préfixe NAT64 dans les données réseau (fd4c:9574:3720:2:0:0::/96 dans notre cas):
> 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
Vérifiez que les données réseau correspondent à celles de l'OTBR.
4. Communiquer avec les hôtes IPv4 à partir de l'appareil final Thread
Vous pouvez désormais communiquer avec les hôtes sur le réseau IPv4 à partir de l'appareil final que nous venons de configurer.
Envoyer des requêtes d’écho ICMP aux hôtes IPv4
Dans la CLI de notre appareil de fin 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
Le routeur de bordure crée un élément de mappage NAT64 pour cet appareil à l'aide de la commande 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 doit correspondre à l'adresse IPv6 de votre appareil Thread.
Exécutez cette commande à tout moment sur le routeur de bordure pour voir comment elle comptabilise le trafic.
Envoyer des requêtes DNS aux serveurs DNS IPv4
Utilisez dns resolve4 pour résoudre un nom d'hôte sur le réseau IPv4. L'adresse du serveur DNS peut également être une adresse 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
Communiquer via TCP
Il est possible d'établir des connexions TCP entre l'appareil final et les hôtes du réseau IPv4.
Supposons que l'adresse IP de votre hôte IPv4 Linux est 192.168.0.2.
Sur votre hôte IPv4 Linux, utilisez nc pour écouter les connexions TCP:
$ nc -l 0.0.0.0 12345
Depuis votre appareil de fin Thread, établissez une connexion TCP et envoyez des messages à votre hôte 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
Sortie de votre hôte IPv4 Linux:
hello
Vous pouvez également envoyer des messages de votre hôte IPv4 Linux à un appareil de fin Thread. Saisir "world" et appuyez sur Entrée sur votre hôte IPv4 Linux exécutant nc, et votre appareil de fin Thread génère le résultat suivant:
TCP: Received 6 bytes: world
Communiquer via UDP
Il est possible de communiquer à l'aide du protocole UDP entre les appareils et les hôtes Thread du réseau IPv4.
Supposons que l'adresse IP de votre hôte IPv4 Linux est 192.168.0.2.
Utilisez nc pour écouter les connexions UDP:
$ nc -u -l 0.0.0.0 12345
Depuis votre appareil de fin Thread, établissez une connexion UDP et envoyez des messages à votre hôte 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
Sortie de votre hôte IPv4 Linux:
hello
Vous pouvez également envoyer des messages de votre hôte IPv4 Linux à un appareil de fin Thread. Saisir "world" et appuyez sur Entrée sur votre hôte IPv4 Linux exécutant nc, et votre appareil de fin Thread génère le résultat suivant:
6 bytes from fd4c:9574:3720:2:0:0:c0a8:2 12345 world
5. Activer/Désactiver NAT64 sur le routeur de bordure
Vous pouvez activer ou désactiver NAT64 à tout moment. Utilisez nat64 disable pour désactiver NAT64. Utilisez nat64 state pour vérifier l'état de NAT64.
$ sudo ot-ctl nat64 disable Done $ sudo ot-ctl nat64 state PrefixManager: Disabled Translator: Disabled Done
Après la désactivation, l'appareil ne publie plus de préfixe 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
De plus, les appareils du réseau Thread ne peuvent plus accéder à l'hôte IPv4 via ce routeur de bordure.
Dans la CLI de notre appareil de fin Thread:
> ping 8.8.8.8 Error 13: InvalidState
Utilisez nat64 enable pour activer NAT64. Il peut s'écouler un certain temps avant que le gestionnaire de préfixes ne commence à annoncer un préfixe NAT64:
$ sudo ot-ctl nat64 enable Done $ sudo ot-ctl nat64 state PrefixManager: Idle Translator: NotWorking Done
Après quelques secondes, les composants NAT64 devraient être opérationnels:
$ 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
Notez que la désactivation de NAT64 effacera la table de mappage:
$ sudo ot-ctl nat64 mappings | | Address | | 4 to 6 | 6 to 4 | +------------------+-------------------------------------------------------------+--------+-------------------------+-------------------------+ | ID | IPv6 | IPv4 | Expiry | Pkts | Bytes | Pkts | Bytes | +------------------+------------------------------------------+------------------+--------+----------+--------------+----------+--------------+ Done
6. Transférer les requêtes DNS aux serveurs DNS en amont
Lorsque NAT64 est activé sur le routeur de bordure, OpenThread tente de transférer les requêtes DNS des domaines Internet aux serveurs DNS en amont.
Cette fonction est compatible avec le serveur DNS-SD interne. Vous devez donc vous assurer que le serveur DNS-SD est activé.
$ sudo ot-ctl srp server state running Done
Si la valeur n'est pas running, activez-la:
$ sudo ot-ctl srp server enable Done
Assurez-vous que le proxy DNS en amont est activé:
$ sudo ot-ctl dns server upstream Enabled Done
Si la valeur n'est pas Enabled, activez-la:
$ sudo ot-ctl dns server upstream enable Done
Sur les appareils finaux, assurez-vous que le client SRP est activé afin qu'il envoie les requêtes DNS au routeur de bordure:
> srp client state Enabled Done
Si la valeur n'est pas Enabled, activez-la:
> srp client autostart enable Done
Sur votre appareil final, assurez-vous que le serveur DNS par défaut est le routeur de bordure:
> dns config Server: [fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf]:53 ResponseTimeout: 6000 ms MaxTxAttempts: 3 RecursionDesired: yes Done
L'adresse IPv6 du serveur (fdd2:0e53:2b87:b93f:50ad:4eea:0450:f1bf dans l'exemple ci-dessus) doit être l'une des adresses de votre routeur de bordure OpenThread.
Vous pouvez maintenant envoyer des requêtes DNS pour des domaines Internet depuis l'appareil final:
> 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. Félicitations
Félicitations ! Vous avez configuré un routeur de bordure compatible avec NAT64 et l'avez utilisé pour fournir un accès Internet aux appareils finaux Thread.
Documentation complémentaire
- Guides OpenThread
- Référence de la CLI OpenThread
- Documentation de référence de l'API OpenThread pour NAT64
- Documentation de référence de l'API OpenThread pour le DNS en amont
- Abstraction de la plate-forme OpenThread pour le DNS