OPC UA-servers detecteren met Akri

Artikel
10/27/2023

Akri is een Kubernetes-resourceinterface waarmee u eenvoudig heterogene leaf-apparaten (zoals IP-camera's en USB-apparaten) beschikbaar kunt maken als resources in een Kubernetes-cluster. Akri detecteert voortdurend knooppunten die toegang hebben tot deze apparaten om workloads op basis van deze apparaten te plannen. Akri is een CNCF-sandboxproject dat is gemaakt voor de rand, dat het dynamische uiterlijk en de verdwijning van leaf-apparaten verwerkt. Het ondersteunt momenteel OPC UA-, ONVIF- en udev-protocollen, maar u kunt ook aangepaste protocolhandlers implementeren die door de sjabloon worden geleverd. Lees hier meer over Akri.

In dit artikel wordt beschreven hoe u voorbeeldcontainers van OPC PLC-servers in Azure kunt implementeren en deze kunt detecteren door Akri te implementeren op uw AKS Edge Essentials-cluster. OPC UA is een communicatieprotocol voor industriële automatisering. Het is een client-/servertechnologie die wordt geleverd met een beveiligings- en communicatieframework. Als u op een bepaald moment in de demo meer wilt weten over OPC UA of een term wilt verduidelijken, raadpleegt u de online OPC UA-specificaties.

Deze demo helpt u aan de slag met Akri om OPC UA-servers te detecteren en deze te gebruiken via een broker die een OPC UA-client bevat. Voor dit scenario is met name een Akri-configuratie met de naam OPC UA Monitoring gemaakt. Deze configuratie laat zien hoe u Akri kunt gebruiken om anomaliewaarden van een specifieke OPC UA-variabele te detecteren. Om dit te doen, abonneren de OPC UA-clients in de brokers zich op die variabele en dienen de waarde ervan via gRPC om een webtoepassing voor anomaliedetectie te gebruiken. U kunt deze configuratie gebruiken om een barometer, CO-detector en meer te bewaken. In dit voorbeeld vertegenwoordigt de variabele OPC UA echter de PLC-waarden (programmeerbare logische controller) voor de temperatuur van een thermostaat. Elke waarde buiten het bereik van 70-80 graden is een anomalie. Als u certificaten wilt gebruiken voor beveiliging, gaat u verder met de sectie aan het einde.

Vereisten

AKS Edge Essentials-cluster is actief.
Azure-abonnement en een resourcegroep waarin OPC PLC-servers moeten worden geïmplementeerd.
Akri werkt alleen op Linux: gebruik Linux-knooppunten voor deze oefening.

OPC UA-servers maken

Maak nu enkele OPC UA PLC-servers om te detecteren. In plaats van helemaal opnieuw te beginnen, implementeert u OPC PLC-servercontainers. U kunt hier meer lezen over de containers en hun parameters. In deze demo wordt gebruikgemaakt van de sjabloon voor het implementeren van CONTAINER-exemplaren van OPC PLC-servers in Azure.

Ga naar de leesmij van het Azure IoT Edge OPC PLC-voorbeeld en selecteer Implementeren in Azure.
Selecteer Sjabloon bewerken en navigeer naar regel 172. Vervang de hele regel door de volgende code om de benodigde vlaggen toe te voegen voor het implementeren van de gewenste OPC PLC-servers:
```
"[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')]"
```
U kunt meer lezen over de parameters in het leesmij-bestand.
Sla de sjabloon op en vul de project- en exemplaargegevens in. Geef Number of Simulations2 voor op om twee OPC PLC-servers uit te voeren.
Selecteer Controleren en maken en vervolgens Maken om uw servers in Azure te implementeren.

U hebt nu twee OPC UA PLC-servers gemaakt, elk met één snel PLC-knooppunt, waarmee een geheel getal zonder teken met ondergrens = 65 en bovengrens = 85 wordt gegenereerd met een snelheid van 1.

Akri uitvoeren

Zorg ervoor dat uw OPC UA-servers worden uitgevoerd door te controleren of de containerinstanties zijn gestart op uw Azure Portal.
Om ervoor te zorgen dat Akri de servers correct detecteert, geeft u de juiste detectie-URL's op bij de installatie van Akri.

Detectie-URL's worden weergegeven als opc.tcp://<FQDN>:50000/. Als u de FQDN's van uw OPC PLC-servers wilt ophalen, gaat u naar uw implementaties in Azure en ziet u de FQDN. Kopieer en plak de FQDN in uw detectie-URL's voor elke server.
Voeg de Akri Helm-grafieken toe als u dit nog niet hebt gedaan:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Als u al eerder een Akri Helm-grafiek hebt toegevoegd, werkt u de opslagplaats bij voor de nieuwste build:
```
helm repo update
```

Installeer Akri met behulp van Helm. Wanneer u Akri installeert, geeft u op dat u de OPC UA-detectiehandlers wilt implementeren door de helm-waarde opcua.discovery.enabled=truein te stellen.

Geef in dit scenario de Identifier en NamespaceIndex op van de NodeID die de brokers moeten controleren. In dit geval is dat de temperatuurvariabele die eerder is gemaakt, met een Identifier van FastUInt1 en NamespaceIndex van 2.

Zorg ervoor dat u de opcua.configuration.discoveryDetails.discoveryUrls vervangt door de URL's die u in de vorige stap hebt verkregen:

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/" `

Notitie

FastUInt1 is de id van het snel veranderende knooppunt dat wordt geleverd door de OPC PLC-server.

Meer informatie over de OPC UA-configuratie-instellingen vindt u hier.

Zodra Akri is geïnstalleerd, detecteert de Akri-agent de twee servers en maakt een exemplaar voor elke server. Bekijk hoe er twee broker-pods worden uitgevoerd, één voor elke server:
```
kubectl get pods -o wide --watch
```
U kunt er ook voor zorgen dat de bewakingspod van Akri verbinding heeft gemaakt met de OPC UA-server:
```
kubectl logs <name of OPC UA monitoring pod>
```
Om meer van de elementen van Akri te inspecteren:
- Voer uit kubectl get crden u ziet dat de CRD's worden vermeld.
- Voer uit kubectl get akricen u ziet akri-opcua-monitoring.
- Als de OPC PLC-servers zijn gedetecteerd en pods zijn gesponnen, kunt u de exemplaren zien door uit te voeren kubectl get akriien kunt u verder inspecteren door uit te voeren kubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Een webtoepassing voor anomaliedetectie implementeren als eindgebruiker van de brokers

Er is een voorbeeldwebtoepassing voor anomaliedetectie gemaakt voor deze end-to-end-demo. Het heeft een gRPC-stub die de gRPC-services van de brokers aanroept, waardoor de meest recente temperatuurwaarde wordt opgehaald. Vervolgens wordt bepaald of deze waarde een uitbijter voor de gegevensset is met behulp van de strategie Lokale uitbijterfactor. De gegevensset is gewoon een CSV-bestand met de getallen tussen 70-80 meerdere keren herhaald; daarom wordt elke waarde die aanzienlijk buiten dit bereik ligt, gezien als een uitbijter. De webtoepassing fungeert als een logboek, met daarin alle temperatuurwaarden en het adres van de OPC UA-server die de waarden heeft verzonden. Er worden afwijkingswaarden in het rood weergegeven. De afwijkingen hebben altijd een waarde van 120 vanwege de wijze waarop de DoSimulation functie is ingesteld in de OPC UA-servers.

Implementeer de anomaliedetectie-app en watch een pod-spin-up voor de app:

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

kubectl get pods -o wide --watch

Zodra de pods worden uitgevoerd, haalt u het IP-adres van het knooppunt en het servicepoortnummer van de app op:
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Navigeer naar http://<NODE IP>:<SERVICE PORT NUM>/. Het duurt een paar seconden voordat de site is geladen. Vervolgens ziet u een logboek met de temperatuurwaarden, die om de paar seconden worden bijgewerkt. Merk op dat de waarden afkomstig zijn van twee verschillende detectie-URL's, met name die voor elk van de twee OPC UA-servers.

Optioneel: certificaten voor de OPC UA-server en -broker

Dit is een optionele procedure die u kunt gebruiken om Akri uit te proberen met certificaten voor extra beveiliging. Volg deze stappen om OPC PLC-servers met beveiliging te implementeren en een Kubernetes-geheim te maken dat kan worden gebruikt om de server en broker te verifiëren.

OPC UA-servers met beveiliging maken

Ga naar de leesmij van het Azure IoT Edge OPC PLC-voorbeeld en selecteer Implementeren in Azure.

Selecteer Sjabloon bewerken en navigeer naar regel 172. Vervang de hele regel door de volgende code om de benodigde vlaggen toe te voegen voor het implementeren van de gewenste OPC PLC-servers:

"[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')]"

Voeg onder de resources sectie de volgende code toe in de derde properties sectie (regel 167) (hetzelfde niveau als image, command, ports, , enzovoort):

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

Voeg vervolgens de volgende code toe in de tweede sectie 'eigenschappen' (regel 163) (hetzelfde niveau als containers):

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

Sla de sjabloon op en vul de project- en exemplaargegevens in. Geef Number of Simulations2 voor op om twee OPC PLC-servers uit te voeren.
Selecteer Controleren en maken en selecteer vervolgens Maken om uw servers in Azure te implementeren.

X.509 v3-certificaten maken

Maak drie OPC UA-compatibele X.509v3-certificaten (één voor de broker en één voor elke server), zodat het certificaat de benodigde onderdelen bevat, zoals een toepassings-URI.

Vereisten voor certificaten:

Ze moeten allemaal worden ondertekend door een gemeenschappelijke certificeringsinstantie (CA) en de ondertekeningsalgoritmen voor alle certificaten moeten zijn SHA256.
De sleutelgrootte moet ook groter zijn dan of gelijk zijn aan 2048 bits.
De DNS van servercertificaten en het AkriBroker-certificaat moeten de FQDN bevatten van het opc UA-servercontainerexemplaar dat is gemaakt (ga naar stap 3 van Akri uitvoeren voor meer informatie over het ophalen van de FQDN).
Het OPC UA-servercertificaat moet de naam OpcPlc hebben (in termen die certificaten genereren, CN=OpcPlc) en het Akri-brokercertificaat moet de naam AkriBroker hebben (CN=AkriBroker) (er zijn geen vereisten voor de CA-naam).

Er zijn veel hulpprogramma's voor het genereren van de juiste certificaten voor OPC UA, zoals de certificaatgenerator van de OPC Foundation of OpenSSL. De certificaatgenerator van OPC Foundation kan een handigere optie zijn, terwijl OpenSSL meer ruimte biedt voor aanpassing.

Als u ervoor kiest om de certificaatgenerator van OPC Foundation te gebruiken, volgt u deze stappen om te bouwen:

Installeer Perl.
Download het .zip-bestand of kloon de certificaatgeneratoropslagplaats van OPC Foundation (Misc-Tools).
Voer uit build_certificate-generator.bat vanaf de Visual Studio-opdrachtprompt voor ontwikkelaars (Visual Studio 2022 wordt aanbevolen).
Bouw Opc.Ua.CertificateGenerator een oplossing vanuit Visual Studio 2022.
Controleer of Opc.Ua.CertificateGenerator.exe het is gebouwd in de build/Debug/Opc.Ua.CertificateGenerator map.

Gebruik de volgende voorbeeldopdrachten om certificaten te maken. Zie Misc-Tools voor meer opties:

Self-Signed CA:

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

OPC UA-servercertificaat:

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

Akri-brokercertificaat:

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

Maak een .crl bestand voor CA met behulp van OpenSSL (alleen als u ca hebt gemaakt op basis van de generator, waardoor het .crl bestand ontbreekt).

Als u ervoor kiest om OpenSSL te gebruiken, volgt hier een lijst met verwijzingen:

Een Kubernetes-geheim voor opcua-broker-credentials maken

Het OPC UA-clientcertificaat wordt doorgegeven aan de OPC UA-bewakingsbroker als een Kubernetes-geheim dat is gekoppeld als een volume.

Maak een Kubernetes-geheim en projecteer elk certificaat/crl/persoonlijke sleutel met de verwachte sleutelnaam (client_certificate, client_key, ca_certificateen ca_crl). Geef de bestandspaden op zodat deze verwijzen naar de referenties die in de vorige sectie zijn gemaakt:

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

Het certificaat wordt gekoppeld aan het volume credentials op de mountPath /etc/opcua-certs/client-pki, zoals wordt weergegeven in de HELM-sjabloon voor opC UA-configuratie. Dit pad is waar de brokers de certificaten verwachten te vinden.

De map met certificaten koppelen aan de ACI

Volg deze instructies om een Azure-bestandsshare te maken.

Nadat u de Azure-bestandsshare en -certificaten hebt gemaakt, uploadt u de CA- en OPC UA-servercertificaten naar de bestandsshare, zoals beschreven.

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

Notitie

Omdat we een vlag voor beveiliging in de sjabloon hebben toegevoegd, wordt er een willekeurig certificaat gegenereerd in de bestandsshare. U kunt niet-geïdentificeerde certificaten in de bestandsshare verwijderen (de mappaden moeten er precies hetzelfde uitzien als in het vorige diagram).

Nadat u deze stappen voor beveiliging hebt uitgevoerd, klikt u op Opnieuw opstarten op uw containerinstantie om het bij te werken en uit te voeren met de gekoppelde certificaten.

Akri uitvoeren en een web-app implementeren

Volg de vorige sectie om Akri uit te voeren en uw servers te detecteren, maar voeg nu een regel --set opcua.configuration.mountCertificates='true' toe aan het einde van de opdracht. Zorg ervoor dat u vervangt door opcua.configuration.discoveryDetails.discoveryUrls de URL's die zijn gevonden in de Azure Portal:

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'

Hier kunt u de sectie over het implementeren van een webtoepassing voor anomaliedetectie als eindgebruiker van de brokers volgen om uw OPC PLC-waarden op uw webpagina te zien.

Opschonen

Verwijder de toepassing voor anomaliedetectie:

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

Verwijder Akri uit uw cluster.
```
helm delete akri
```
Verwijder de implementatie van de OPC UA-server door naar uw containerinstantie te navigeren en selecteer vervolgens Verwijderen in de Azure Portal.

Volgende stappen

Overzicht van AKS Edge Essentials

Delen via