Découvrir les serveurs OPC UA avec Akri

Article
10/17/2023

Akri est une interface de ressources Kubernetes qui vous permet d’exposer facilement des appareils feuilles hétérogènes (tels que des caméras IP et des appareils USB) en tant que ressources dans un cluster Kubernetes. Akri détecte continuellement les nœuds qui ont accès à ces appareils pour planifier des charges de travail en fonction de ceux-ci. Akri est un projet de bac à sable CNCF destiné à la périphérie, qui gère l’apparence dynamique et la disparition des dispositifs à feuilles. Il prend actuellement en charge les protocoles OPC UA, ONVIF et udev, mais vous pouvez également implémenter des gestionnaires de protocoles personnalisés fournis par le modèle. Pour en savoir plus sur Akri, cliquez ici.

Cet article explique comment déployer des exemples de conteneurs de serveur OPC PLC dans Azure et les découvrir en déployant Akri sur votre cluster AKS Edge Essentials. OPC UA est un protocole de communication pour l’automatisation industrielle. Il s’agit d’une technologie client/serveur fournie avec une infrastructure de sécurité et de communication. Si, à un moment quelconque de la démonstration, vous souhaitez approfondir OPC UA ou clarifier un terme, consultez les spécifications OPC UA en ligne.

Cette démonstration vous aide à commencer à utiliser Akri pour découvrir les serveurs OPC UA et les utiliser via un répartiteur qui contient un client OPC UA. Plus précisément, une configuration Akri appelée supervision OPC UA a été créée pour ce scénario. Cette configuration montre comment utiliser Akri pour détecter les valeurs d’anomalie d’une variable OPC UA spécifique. Pour ce faire, les clients OPC UA dans les répartiteurs s’abonnent à cette variable et servent sa valeur sur gRPC pour une application web de détection d’anomalies à consommer. Vous pouvez utiliser cette configuration pour surveiller un baromètre, un détecteur de CO, etc. Toutefois, pour cet exemple, la variable OPC UA représente les valeurs PLC (contrôleur logique programmable) pour la température d’un thermostat. Toute valeur située en dehors de la plage de 70-80 degrés est une anomalie. En outre, si vous souhaitez utiliser des certificats pour la sécurité, passez à la section à la fin.

Prérequis

Cluster AKS Edge Essentials opérationnel.
Un abonnement Azure et un groupe de ressources sur lequel déployer des serveurs OPC PLC.
Akri fonctionne uniquement sur Linux : utilisez des nœuds Linux pour cet exercice.

Créer des serveurs OPC UA

Maintenant, créez des serveurs OPC UA PLC à découvrir. Au lieu de partir de zéro, déployez des conteneurs de serveur OPC PLC. Vous pouvez en savoir plus sur les conteneurs et leurs paramètres ici. Cette démonstration utilise le modèle fourni pour déployer des instances de conteneur de serveur OPC PLC sur Azure.

Accédez au fichier lisez-moi de l’exemple Azure IoT Edge OPC PLC, puis sélectionnez Déployer sur Azure.
Sélectionnez Modifier le modèle et accédez à la ligne 172. Remplacez toute la ligne par le code suivant pour ajouter les indicateurs nécessaires au déploiement des serveurs OPC PLC souhaités :
```
"[concat('./opcplc --pn=50000 --sph --fn=1 --fr=1 --ft=uint --ftl=65 --ftu=85 --ftr=True --aa --sph --ftl=65 --ftu=85 --ftr=True --ut', ' --ph=', variables('aciPlc'), add(copyIndex(), 1), '.', resourceGroup().location, '.azurecontainer.io')]"
```
Vous pouvez en savoir plus sur les paramètres dans le fichier readme.
Enregistrez le modèle et renseignez le projet et instance détails. Pour Number of Simulations, spécifiez 2 afin d’exécuter deux serveurs OPC PLC.
Sélectionnez Vérifier et créer, puis Créer pour déployer vos serveurs sur Azure.

Vous avez maintenant créé avec succès deux serveurs OPC UA PLC, chacun avec un nœud PLC rapide, qui génère un entier non signé avec une limite inférieure = 65 et une limite supérieure = 85 à un taux de 1.

Exécuter Akri

Vérifiez que vos serveurs OPC UA sont en cours d’exécution en vérifiant que les instances de conteneur ont été démarrées sur votre Portail Azure.
Pour qu’Akri découvre correctement les serveurs, spécifiez les URL de découverte appropriées lors de l’installation d’Akri.

Les URL de découverte s’affichent sous la forme opc.tcp://<FQDN>:50000/. Pour obtenir les noms de domaine complets de vos serveurs OPC PLC, accédez à vos déploiements dans Azure et vous verrez le nom de domaine complet. Copiez et collez le nom de domaine complet dans vos URL de découverte pour chaque serveur.
Ajoutez les graphiques Helm Akri, si vous ne l’avez pas déjà fait :
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Si vous avez déjà ajouté le graphique Helm Akri précédemment, mettez à jour votre dépôt pour la dernière version :
```
helm repo update
```
Installez Akri à l’aide de Helm. Lorsque vous installez Akri, spécifiez que vous souhaitez déployer les gestionnaires de découverte OPC UA en définissant la valeur opcua.discovery.enabled=truehelm .

Dans ce scénario, spécifiez le Identifier et NamespaceIndex de l’ID de nœud que les répartiteurs doivent surveiller. Dans ce cas, il s’agit de la variable de température créée précédemment, qui a un Identifier de FastUInt1 et NamespaceIndex de 2.

Veillez à remplacer par opcua.configuration.discoveryDetails.discoveryUrls les URL que vous avez obtenues à l’étape précédente :
```
helm install akri akri-helm-charts/akri `
   --set opcua.discovery.enabled=true `
   --set opcua.configuration.enabled=true `
   --set opcua.configuration.name=akri-opcua-monitoring `
   --set opcua.configuration.brokerPod.image.repository="ghcr.io/project-akri/akri/opcua-monitoring-broker" `
   --set opcua.configuration.brokerPod.image.tag="latest-dev" `
   --set opcua.configuration.brokerProperties.IDENTIFIER='FastUInt1' `
   --set opcua.configuration.brokerProperties.NAMESPACE_INDEX='2' `
   --set opcua.configuration.discoveryDetails.discoveryUrls[0]="opc.tcp://<FQDN of 1st container instance>:50000/" `
   --set opcua.configuration.discoveryDetails.discoveryUrls[1]="opc.tcp://<FQDN of 2nd container instance>:50000/" `
```
Notes

FastUInt1 est l’identificateur du nœud à évolution rapide fourni par le serveur OPC PLC.

Pour en savoir plus sur les paramètres de configuration OPC UA, cliquez ici.
Une fois Akri installé, l’agent Akri découvre les deux serveurs et crée une instance pour chaque serveur. Regardez la rotation de deux pods broker, un pour chaque serveur :
```
kubectl get pods -o wide --watch
```
Vous pouvez également vous assurer que le pod de surveillance d’Akri s’est correctement connecté au serveur OPC UA :
```
kubectl logs <name of OPC UA monitoring pod>
```
Pour inspecter d’autres éléments d’Akri :
- Exécutez kubectl get crd, et vous devez voir les CRD répertoriés.
- Exécutez kubectl get akric, et vous devriez voir akri-opcua-monitoring.
- Si les serveurs OPC PLC ont été découverts et que les pods ont été créés, vous pouvez voir les instances en exécutant kubectl get akrii, et vous pouvez inspecter davantage en exécutant kubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Déployer une application web de détection d’anomalies en tant que consommateur final des répartiteurs

Un exemple d’application web de détection d’anomalies a été créé pour cette démonstration de bout en bout. Il a un stub gRPC qui appelle les services gRPC des courtiers, obtenant la dernière valeur de température. Il détermine ensuite si cette valeur est une valeur aberrante pour le jeu de données à l’aide de la stratégie facteur d’exception local. Le jeu de données est simplement un fichier CSV dont les nombres sont entre 70 et 80 répétés plusieurs fois ; par conséquent, toute valeur significativement en dehors de cette plage sera considérée comme une valeur aberrante. L’application web sert de journal, affichant toutes les valeurs de température et l’adresse du serveur OPC UA qui a envoyé les valeurs. Il affiche les valeurs d’anomalie en rouge. Les anomalies ont toujours la valeur 120 en raison de la façon dont la DoSimulation fonction est configurée dans les serveurs OPC UA.

Déployez l’application de détection des anomalies et watch une rotation de pod pour l’application :

kubectl apply -f https://raw.githubusercontent.com/project-akri/akri/main/deployment/samples/akri-anomaly-detection-app.yaml

kubectl get pods -o wide --watch

Une fois les pods en cours d’exécution, obtenez l’adresse IP de votre nœud et le numéro de port de service de l’application :
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Accédez à http://<NODE IP>:<SERVICE PORT NUM>/. Le chargement du site prend quelques secondes, puis vous devez voir un journal des valeurs de température, qui est mis à jour toutes les quelques secondes. Notez comment les valeurs proviennent de deux URL de découverte différentes, en particulier celles de chacun des deux serveurs OPC UA.

Facultatif : certificats pour le serveur OPC UA et le répartiteur

Il s’agit d’une procédure facultative que vous pouvez utiliser pour essayer Akri avec des certificats pour une sécurité accrue. Suivez ces étapes pour déployer des serveurs OPC PLC avec sécurité et créer un secret Kubernetes qui peut être utilisé pour authentifier le serveur et le répartiteur.

Créer des serveurs OPC UA avec sécurité

Accédez au fichier lisez-moi de l’exemple Azure IoT Edge OPC PLC, puis sélectionnez Déployer sur Azure.

Sélectionnez Modifier le modèle et accédez à la ligne 172. Remplacez toute la ligne par le code suivant pour ajouter les indicateurs nécessaires au déploiement des serveurs OPC PLC souhaités :

"[concat('./opcplc --pn=50000 --sph --fn=1 --fr=1 --ft=uint --ftl=65 --ftu=85 --ftr=True --aa --sph --ftl=65 --ftu=85 --ftr=True', ' --ph=', variables('aciPlc'), add(copyIndex(), 1), '.', resourceGroup().location, '.azurecontainer.io')]"

Sous la resources section, ajoutez le code suivant à l’intérieur de la troisième properties section (ligne 167) (même niveau que image, command, ports, etc.) :

"volumeMounts": [
                  {
                  "name": "filesharevolume",
                  "mountPath": "/app/pki"
                  }
                ],

Ensuite, ajoutez le code suivant à l’intérieur de la deuxième section « properties » (ligne 163) (même niveau que containers) :

"volumes": [
               {
                  "name": "filesharevolume",
                  "azureFile": {
                        "shareName": "acishare",
                        "storageAccountName": "<storageAccName>",
                        "storageAccountKey": "<storageAccKey>"
                  }
               }
           ]

Enregistrez le modèle et renseignez le projet et instance détails. Pour Number of Simulations, spécifiez 2 afin d’exécuter deux serveurs OPC PLC.
Sélectionnez Vérifier et créer, puis créer pour déployer vos serveurs sur Azure.

Créer des certificats X.509 v3

Créez trois certificats X.509v3 conformes OPC UA (un pour le répartiteur et un pour chaque serveur), en vous assurant que le certificat contient les composants nécessaires, tels qu’un URI d’application.

Configuration requise pour les certificats :

Ils doivent tous être signés par une autorité de certification commune, et les algorithmes de signature de tous les certificats doivent être SHA256.
La taille de clé doit également être supérieure ou égale à bits 2048 .
Le DNS des certificats de serveur et le certificat AkriBroker doivent contenir le nom de domaine complet du conteneur de serveur OPC UA instance créé (accédez à l’étape 3 de l’exécution d’Akri pour savoir comment obtenir le nom de domaine complet).
Le certificat de serveur OPC UA doit être nommé OpcPlc (en termes de génération de certificats, CN=OpcPlc) et le certificat du répartiteur Akri doit être nommé AkriBroker (CN=AkriBroker) (il n’existe aucune configuration requise pour le nom de l’autorité de certification).

Il existe de nombreux outils permettant de générer des certificats appropriés pour OPC UA, tels que le générateur de certificats de la Fondation OPC ou OpenSSL. Le générateur de certificats de la Fondation OPC peut être une option plus pratique, tandis qu’OpenSSL offre plus d’espace pour la personnalisation.

Si vous choisissez d’utiliser le générateur de certificats d’OPC Foundation, procédez comme suit pour générer :

Installez Perl.
Téléchargez le fichier .zip ou clonez le référentiel générateur de certificats de la Fondation OPC (Misc-Tools).
Exécutez build_certificate-generator.bat à partir de l’invite de commandes du développeur Visual Studio (Visual Studio 2022 est recommandé).
Générez la Opc.Ua.CertificateGenerator solution à partir de Visual Studio 2022.
Vérifiez si Opc.Ua.CertificateGenerator.exe a été correctement créé dans le build/Debug/Opc.Ua.CertificateGenerator répertoire.

Utilisez les exemples de commandes suivants pour créer des certificats. Pour plus d’options, consultez Misc-Tools :

Self-Signed autorité de certification :

.\Opc.Ua.CertificateGenerator.exe -cmd issue -sp . -sn CN=<CA name e.g. MyCA> -ca true -pw <password>

Certificat de serveur OPC UA :

.\Opc.Ua.CertificateGenerator.exe -cmd issue -sp . -an OpcPlc -ikf '.\private\MyCA [hash].pfx' -ikp <password>-dn <DNS separated by commas>

Certificat de répartiteur Akri :

.\Opc.Ua.CertificateGenerator.exe -cmd issue -sp . -an AkriBroker -ikf '.\private\MyCA [hash].pfx' -ikp <password>-dn <DNS separated by commas>

Créez un .crl fichier pour l’autorité de certification à l’aide d’OpenSSL (uniquement si vous avez créé l’autorité de certification à partir du générateur, qui manquerait le .crl fichier).

Si vous choisissez d’utiliser OpenSSL, voici une liste de références :

Créer un secret Kubernetes opcua-broker-credentials

Le certificat client OPC UA est passé au répartiteur de surveillance OPC UA sous la forme d’un secret Kubernetes monté en tant que volume.

Créez un secret Kubernetes, en projetant chaque certificat/crl/clé privée avec le nom de clé attendu (client_certificate, , client_keyca_certificateet ca_crl). Spécifiez les chemins d’accès aux fichiers afin qu’ils pointent vers les informations d’identification créées dans la section précédente :

kubectl create secret generic opcua-broker-credentials `
--from-file=client_certificate=/path/to/AkriBroker/own/certs/AkriBroker\ \[<hash>\].der `
--from-file=client_key=/path/to/AkriBroker/own/private/AkriBroker\ \[<hash>\].pfx `
--from-file=ca_certificate=/path/to/ca/certs/SomeCA\ \[<hash>\].der `
--from-file=ca_crl=/path/to/ca/crl/SomeCA\ \[<hash>\].crl

Le certificat est monté sur le volume credentials à l’emplacement mountPath /etc/opcua-certs/client-pki, comme indiqué dans le modèle helm de configuration OPC UA. Ce chemin d’accès est l’endroit où les répartiteurs s’attendent à trouver les certificats.

Monter le dossier des certificats sur ACI

Suivez ces instructions pour créer un partage de fichiers Azure.

Après avoir créé le partage de fichiers Et les certificats Azure, chargez les certificats de l’autorité de certification et du serveur OPC UA sur le partage de fichiers comme décrit.

├── own
│   ├── certs
│   │   └── OpcPlc [hash].der
│   └── private
│       └── OpcPlc [hash].pfx
└── trusted
    ├── certs
    │   └── CA.der
    └── crl
        └── CA.crl

Notes

Étant donné que nous avons ajouté un indicateur de sécurité dans le modèle, un certificat arbitraire est généré dans le partage de fichiers. Vous pouvez supprimer tous les certificats non identifiés dans le partage de fichiers (les chemins d’accès aux dossiers doivent ressembler exactement au diagramme précédent).

Après avoir suivi ces étapes pour la sécurité, cliquez sur Redémarrer sur votre conteneur instance pour le mettre à jour et l’exécuter avec les certificats montés.

Exécuter Akri et déployer une application web

Suivez la section précédente pour exécuter Akri et découvrir vos serveurs, mais ajoutez maintenant une ligne --set opcua.configuration.mountCertificates='true' à la fin de la commande. Veillez à remplacer par opcua.configuration.discoveryDetails.discoveryUrls les URL trouvées dans le Portail Azure :

helm install akri akri-helm-charts/akri `
   --set opcua.discovery.enabled=true `
   --set opcua.configuration.enabled=true `
   --set opcua.configuration.name=akri-opcua-monitoring `
   --set opcua.configuration.brokerPod.image.repository="ghcr.io/project-akri/akri/opcua-monitoring-broker" `
   --set opcua.configuration.brokerPod.image.tag="latest-dev" `
   --set opcua.configuration.brokerProperties.IDENTIFIER='FastUInt1' `
   --set opcua.configuration.brokerProperties.NAMESPACE_INDEX='2' `
   --set opcua.configuration.discoveryDetails.discoveryUrls[0]="opc.tcp://<FQDN of 1st container instance>:50000/" `
   --set opcua.configuration.discoveryDetails.discoveryUrls[1]="opc.tcp://<FQDN of 2nd container instance>:50000/" `
   --set opcua.configuration.mountCertificates='true'

À partir de là, vous pouvez suivre la section sur le déploiement d’une application web de détection d’anomalies en tant que consommateur final des répartiteurs pour voir vos valeurs OPC PLC sur votre page web.

Nettoyage

Supprimez l’application de détection d’anomalie :

kubectl delete -f https://raw.githubusercontent.com/project-akri/akri/main/deployment/samples/akri-anomaly-detection-app.yaml

Désinstallez Akri de votre cluster.
```
helm delete akri
```
Supprimez le déploiement du serveur OPC UA en accédant à votre instance de conteneur, puis sélectionnez Supprimer dans le Portail Azure.

Étapes suivantes

Vue d’ensemble d’AKS Edge Essentials

Partager via