Au cours de la dernière année, nous avons conçu (et continuons de soutenir) plusieurs projets IIoT. Vous avez peut-être entendu parler de l'IIoT, mais au cas où, nous essaierons d'expliquer le plus simplement possible de quoi il s'agit et pourquoi il est intéressant pour les développeurs, architectes et administrateurs de solutions très chargées.
L'IoT - l'Internet des objets - implique de contrôler des appareils conçus pour effectuer des tâches ménagères simples (ouvrir la porte du garage lorsque la voiture s'arrête, allumer la lumière à l'aide d'un capteur de mouvement ou d'une commande, surveiller la température ambiante), puis sous IIoT - l'Internet industriel des objets - il y a généralement en vue de la «numérisation» des données des industries, sur la base desquelles une analyse experte peut être réalisée, souvent à l'aide du machine learning.
Par exemple, vous pouvez collecter et analyser les données des moteurs rotatifs afin de connaître les défaillances dans le temps et d'économiser sur les réparations. Le remplacement d'une turbine complètement cassée coûte beaucoup plus cher qu'une réparation en temps opportun. Un autre exemple est l'extraction du charbon. L'analyse des données sur la composition de l'air dans les mines vous permet de répondre à temps au dépassement des valeurs autorisées. Cela aide à prévenir les situations potentiellement mortelles pour les mineurs.
Le flux de données - des capteurs de terrain, des machines industrielles, des capteurs de gaz - va aux centres d'agrégation et, plus loin, à la plateforme de traitement et d'analyse des données.
Nous voulons parler de l'apparence d'une telle architecture, comment collecter et analyser des données tout simplement et nous attarder sur les spécificités des applications individuelles. Nous nous appuierons sur des traductions d'articles en anglais et sur notre propre expérience de conception. Cet article est traduit , avec nos explications et ajouts.
Dans le premier article, nous allons essayer de créer une architecture IIoT, dans laquelle nous continuerons à transmettre des données à partir de capteurs, puis à les transférer vers un système qui fournit le traitement, l'analyse, l'apprentissage automatique et la surveillance des données entrantes.
Architecture créée
Souvent, dans l'IoT industriel, il n'y a pas d'accès direct aux capteurs et systèmes de contrôle, par conséquent, une passerelle est utilisée pour connecter les niveaux OT (technologie d'exploitation) et IT (technologie de l'information).
Ainsi, l'architecture IIoT comprend généralement: des terminaux, des passerelles, des hubs régionaux et, enfin, des systèmes de traitement et de stockage de l'information.
L'architecture créée devrait fournir une opportunité:
- Collectez les données des capteurs vers la passerelle
- Transférer des données vers le cloud ou le centre de données
- Mettre Ă jour automatiquement les configurations de passerelle
- Maintenir le transfert et le traitement sécurisés des données
Sur l'image: architecture du système créé et des logiciels que nous utiliserons pour le construire à chaque niveau.
Les capteurs collectent les données et les envoient à la passerelle à l'aide d'une variété de protocoles filaires et sans fil (série, RS-485, MODBUS, bus CAN, OPC UA, BLE, WiFi, etc.). Dans notre exemple, nous garderons à l'esprit que les données parviennent à la passerelle via le WiFi.
Comme passerelle, nous utiliserons le Raspberry Pi, sur lequel le courtier Mosquitto et l'agent MiNiFi seront lancés. Mosquitto est un courtier de messages léger et open source que nous utiliserons pour transmettre davantage les données des capteurs à l'aide du protocole MQTT. MQTT ajoute une surcharge minimale et est donc pratique à utiliser dans l'IoT lorsque les ressources matérielles des périphériques finaux sont limitées (par exemple, des téléphones et des microcontrôleurs sont utilisés).
Apache MiNiFi - un sous-projet Apache NiFi - un agent léger qui implémente les fonctionnalités de base d'Apache NiFi, spécialement conçu pour collecter des données sur les terminaux.
MiNiFi est compact, utilise peu de ressources et permet une gestion centralisée de tous les agents. Il se connecte facilement au NiFi à l'aide de Site à site (S2S), ce qui vous permet de créer un contrôle de flux de données à part entière - évolutif, sécurisé et donnant une idée claire de toutes les étapes du transfert d'informations.
Dans notre système, MiNiFi s'abonnera à tous les sujets du courtier Mosquitto et transmettra chaque message à NiFi défini au niveau régional. Vous pouvez également l'utiliser pour vous connecter à un système SCADA ou à toute autre source de données OT.
Au niveau régional, il y a deux composantes:
Apache NiFi est un puissant système de gestion de flux de données qui prend en charge plus de 200 connecteurs. Une interface graphique vous permet de concevoir rapidement et facilement des flux de données.
NiFi ne sacrifie pas le pouvoir pour la simplicité. Il s'agit d'un système distribué bien évolutif avec une livraison garantie, une contre-pression (la capacité de stocker des données avant de les télécharger sur d'autres systèmes plus lents) et un équilibrage de charge. Cette fonctionnalité fait de NiFi un excellent outil pour les applications IoT qui fonctionnent souvent dans des environnements réseau instables.
Dans notre système, NiFi est un centre de collecte de données qui les redirige vers divers systèmes et applications (HDFS, HBase, Kafka, S3, etc.).
Le serveur MiNiFi C2 (MiNiFi Command & Control) est un autre sous-projet Apache NiFi qui est toujours en cours de développement. Son rôle est d'être le point central de la configuration de centaines et de milliers d'agents MiNiFi en production sur le terrain (halls divers, usines, territoires). Le serveur C2 gère les configurations de flux MiNiFi (dans la terminologie C2 - classe d'applications versionnée) et les publie via l'API Rest. Les agents MiNiFi peuvent se connecter à cette API à une fréquence donnée pour mettre à jour leur propre configuration.
Commençons donc à créer notre prototype.
Contrat de nom de domaine
Pour une configuration plus approfondie des différents systèmes qui devraient se contacter, convenons des noms de domaine que nous utiliserons dans les configurations.
Préparation du Raspberry Pi: MQTT et MiNiFi
Pour installer le courtier MQTT Mosquitto et l'agent MiNiFi, exécutez les commandes suivantes sur votre Raspberry Pi.
Par défaut, MiNiFi contient un ensemble minimal de gestionnaires de données. Vous pouvez ajouter des gestionnaires supplémentaires à partir du kit NiFI en ajoutant une archive NAR (archive NiFi) au répertoire de la bibliothèque.
Avec la dernière commande, nous ajoutons le gestionnaire NAR MQTT.
sudo apt-get update
Installons maintenant le serveur de gestion de configuration MiNiFi C2 sur le serveur qui sera disponible avec le Raspberry Pi
Installation et configuration du serveur MiNiFi C2.
Installez le serveur MiNiFi C2 sur un serveur public qui sera disponible avec les agents MiNiFi. Vous pouvez utiliser la distribution hiérarchique des serveurs C2 pour les infrastructures réseau complexes, comme décrit ci-dessous. Exécutez la commande suivante pour installer le serveur C2:
wget http://apache.crihan.fr/dist/nifi/minifi/0.4.0/minifi-c2-0.4.0-bin.tar.gz tar -xvf minifi-c2-0.4.0-bin.tar.gz cd minifi-c2-0.4.0
- Le serveur C2 publiera la configuration organisée par classe. C2 prend en charge les «fournisseurs de configuration» enfichables:
- CacheConfigurationProvider, qui met à jour la configuration en fonction de la configuration spécifiée dans le système de fichiers ou sur S3
- Le DelegatingConfigurationProvider, qui transmet la délégation à un autre serveur C2 pour créer des structures hiérarchiques de serveurs C2.
- Le NiFiRestConfigurationProvider, qui supprime les modèles des serveurs Apache NiFi via leur API REST.
Nous allons configurer le serveur C2 pour utiliser NiFi comme fournisseur de configuration. Modifiez le fichier ./conf/minifi-c2-context.xml, décommentez le bloc xml
<bean class="org.apache.nifi.minifi.c2.provider.nifi.rest.NiFiRestConfigurationProvider">
et notez l'adresse du serveur NiFi ( http: //nifi.iot.local: 8080 )
<constructor-arg> <value>http://nifi.iot.local:8080/nifi-api</value> </constructor-arg>
Configuration supplémentaire de MiNiFi sur le Raspberry Pi
Par défaut, pour ajouter des gestionnaires et leurs configurations, vous devez modifier la configuration ./conf/config.yml. La configuration peut également être écrite manuellement ou créée à l'aide de l'interface graphique Apache NiFi, suivie de l'exportation de la configuration en tant que modèle. Un modèle est un fichier XML qui doit être converti en un fichier de configuration MiMLiFi YML à l'aide de la boîte à outils MiNiFi. Voici un exemple de fichier de configuration qui surveille le fichier sur l'appareil et transfère chaque nouvelle ligne à NiFi à l'aide du protocole S2S.
Pour notre projet, nous n'utiliserons pas de réglage manuel. En effet, s'il y a beaucoup d'agents MiNiFi, il ne sera pas facile d'arrêter manuellement, de modifier config.yml et de redémarrer l'agent chaque fois que la configuration change.
MiNiFi utilise Change Ingestor, avec lequel l'agent apprend les nouvelles configurations possibles. Change Ingestor est un plug-in, et il y a trois ChangeIngestor qui sont nativement pris en charge par MiNiFi.
- FileChangeIngestor
- RestChangeIngestor
- PullHttpChangeIngestor
Nous utiliserons PullHttpChangeIngestor pour accéder périodiquement au serveur C2 et télécharger la nouvelle configuration. Pour configurer cet Ingestor, vous devez modifier le fichier ./conf/bootstrap.conf, décommenter les lignes correspondantes et définir les paramètres suivants:
nifi.minifi.notifier.ingestors=org.apache.nifi.minifi.bootstrap.configuration.ingestors.PullHttpChangeIngestor
Avec cette configuration, chaque agent MiNiFi accède au serveur C2 en utilisant le protocole API REST à http: //minifi-c2.iot.local: 10080 / c2 / config chaque minute et demande une nouvelle configuration pour la classe d'agent iot-minifi-raspberry
Un point important: la fréquence de 1 minute est réglée pour la démonstration uniquement. Dans un environnement de production, vous n'aurez probablement pas à mettre à jour les agents avec une telle fréquence.
Avant de démarrer l'agent, passons au niveau de contrôle et configurons le serveur MiNiFi C2 et Apache NiFi lui-même.
Installer et configurer un serveur NiFi
Installez le serveur NiFi accessible depuis le serveur C2 et démarrez-le.
wget http://apache.crihan.fr/dist/nifi/1.6.0/nifi-1.6.0-bin.tar.gz tar -xvf nifi-1.6.0-bin.tar.gz cd nifi-1.6.0 ./bin/nifi.sh start
Connectez-vous à l'interface NiFi à http: // nifi-dev: 8080 / nifi / et créez un flux qui s'exécutera sur les agents MiNiFi, mais avant cela, ajoutez le port d'entrée (ajouté en appuyant sur le bouton Input Port du menu) dans la couche racine et nommez-le de Raspberry MiNiFi. C'est là que NiFi recevra les fichiers de flux de MiNiFi.
Ajoutez l'entonnoir et connectez le port d'entrée à l'entonnoir - dans les prochains articles, nous aborderons le traitement des données côté Apache NiFi.
Ajoutez un processeur consumeMQTT pour vous abonner au courtier Mosquitto et signez-le sur tous les sujets iot / capteurs / * notez que tcp: // raspberrypi: 1883 est équivalent à tcp: // localhost: 1883, car ce thread s'exécutera sur Raspberry Pi
Utilisez le Processor UpdateAttribute pour ajouter l'attribut «version», que nous utiliserons pour informer le système de la reconfiguration. Vous pouvez ajouter des attributs supplémentaires: horodatage, emplacement, nom de l'agent, etc.
Enfin, ajoutez le Remote Process Group (RPG) - pour envoyer les événements reçus au NiFi. Combinez ces trois processus.
Votre flux devrait maintenant ressembler à la capture d'écran ci-dessous. Le flux de gauche sera lancé sur Apache NiFi lui-même et recevra les données d'Apache MiNiFi. Le thread de droite ne démarre pas dans Apache Nifi, créé à des fins de prototypage et de configuration, et s'exécute sur le Raspberry Pi.
Enregistrez le flux droit en tant que modèle nommé «iot-minifi-raspberry-agent.v1». Le principe de dénomination est extrêmement important ici. Nous devons utiliser le même nom que le nom de classe utilisé dans la configuration MiNiFi.
C'est très important - vous devez mettre en évidence non seulement les composants stockés, mais aussi les relations entre eux.
Placement et lancement de l'application
Avant de lancer les agents MiNiFi sur le Raspberry Pi, vérifions que le serveur C2 est correctement configuré. Ouvrez l'URL dans votre navigateur: http: // c2-server: 10080 / c2 / config? Class = iot-minifi-raspberry-agent & version = 1 C2 Server doit répondre avec un fichier contenant la configuration du modèle que nous avons construit au format YML.
Si, au lieu de la configuration, le serveur lève une exception Java, vous rencontrez un problème sur le serveur C2 mentionné ici:
https://github.com/apache/nifi-minifi/pull/126#issuecomment-388856304
Vous devrez soit installer la version 0.3.0, soit supprimer le fichier javax.ws.rs-api-2.1.jar du dossier lib du répertoire du serveur C2.
Si vous regardez les journaux du serveur C2, vous pouvez voir que le serveur a accepté la demande avec les paramètres {class = [iot-minifi-raspberry-agent], version = [1]}
Maintenant que la connexion entre les composants d'architecture individuels (MQTT, MiNiFi, NiFi et C2) est établie, démarrez l'agent MiNiFi sur le Raspberry Pi à l'aide de la commande:
./bin/minifi.sh start
Après quelques secondes, vous devriez voir les journaux du serveur C2. L'hôte 192.168.1.50 (dans notre cas, l'adresse IP du périphérique Raspberry Pi) a demandé au serveur C2 de fournir la dernière version de la classe «iot-minifi-raspberry-agent». Par rapport à notre précédente demande, que nous avions faite dans le navigateur, vous pouvez noter que MiNiFi n'a pas indiqué la version. Si vous ouvrez la configuration de l'agent MiNiFi dans ./conf/config.yml, vous verrez la même configuration que nous avons reçue dans le navigateur, définissant la demande à la main.
MQTT montre que l'agent MiNiFi connecté au courtier et abonné aux sujets iot / capteurs / #
ContrĂ´le de transmission
Génial, maintenant, faisons en sorte que nos capteurs commencent à générer des données et à les publier sur MQTT. MiNiFi commencera à télécharger des informations et à envoyer à NiFi, comme indiqué dans la capture d'écran ci-dessous.
Important: Pour que le composant Apache NiFi commence Ă fonctionner, vous devez cliquer sur le bouton Lecture.
Maintenant, jetons un coup d'œil à l'un de ces messages dans NiFi. Les informations proviennent du capteur «iot / capteurs / LightIntensity / z», version d'application - 1
Mise Ă jour de la configuration MiNiFi
Maintenant que notre infrastructure fonctionne et que les données vont à notre «centre de données», installons une nouvelle configuration MiNiFi. Accédez à l'interface Apache NiFi et modifiez le gestionnaire updateAttribute. Remplacez l'attribut «version» par 2 au lieu de 1 et enregistrez le nouveau modèle «iot-minifi-raspberry-agent.v2». C’est tout. La nouvelle configuration sera automatiquement déployée.
Vous pouvez consulter les journaux du serveur C2 et voir qu'une nouvelle version de V2 a été détectée, le serveur ne l'a pas trouvée dans son cache et l'a chargée.
Puis MiNiFi découvre la nouvelle configuration, réserve la configuration précédente, décharge la nouvelle et redémarre:
Dans le prochain article, nous parlerons de la façon dont nous avons assemblé les capteurs et les avons incorporés dans notre architecture. Après cela, nous parlerons de l'analyse des données.