Upptäck OPC UA-servrar med Akri

Artikel
10/27/2023

Akri är ett Kubernetes-resursgränssnitt som gör att du enkelt kan exponera heterogena lövenheter (till exempel IP-kameror och USB-enheter) som resurser i ett Kubernetes-kluster. Akri identifierar kontinuerligt noder som har åtkomst till dessa enheter för att schemalägga arbetsbelastningar baserat på dem. Akri är ett CNCF sandbox-projekt som skapats för kanten, som hanterar det dynamiska utseendet och försvinnandet av lövenheter. Det stöder för närvarande OPC UA-, ONVIF- och udev-protokoll, men du kan också implementera anpassade protokollhanterare som tillhandahålls av mallen. Läs mer om Akri här.

Den här artikeln beskriver hur du kan distribuera OPC PLC-servercontainrar i Azure och identifiera dem genom att distribuera Akri i ditt AKS Edge Essentials-kluster. OPC UA är ett kommunikationsprotokoll för industriell automatisering. Det är en klient-/serverteknik som levereras med ett ramverk för säkerhet och kommunikation. Om du vid något tillfälle i demon vill fördjupa dig i OPC UA eller förtydliga en term kan du läsa specifikationerna för OPC UA online.

Den här demonstrationen hjälper dig att komma igång med Akri för att identifiera OPC UA-servrar och använda dem via en asynkron meddelandekö som innehåller en OPC UA-klient. Mer specifikt skapades en Akri-konfiguration med namnet OPC UA Monitoring för det här scenariot. Den här konfigurationen visar hur du kan använda Akri för att identifiera avvikelsevärden för en specifik OPC UA-variabel. För att göra det prenumererar OPC UA-klienterna i asynkrona meddelandeköer på den variabeln och hanterar dess värde över gRPC för en webbapp för avvikelseidentifiering som ska användas. Du kan använda den här konfigurationen för att övervaka en barometer, CO-detektor med mera. I det här exemplet representerar dock OPC UA-variabeln PLC-värdena (programmerbar logikstyrenhet) för temperaturen för en termostat. Alla värden utanför intervallet 70–80 grader är en avvikelse. Om du vill använda certifikat för säkerhet går du dessutom vidare till avsnittet i slutet.

Förutsättningar

AKS Edge Essentials-klustret är igång.
Azure-prenumeration och en resursgrupp som OPC PLC-servrar ska distribueras till.
Akri fungerar bara på Linux: använd Linux-noder för den här övningen.

Skapa OPC UA-servrar

Skapa nu några OPC UA PLC-servrar att identifiera. Distribuera OPC PLC-servercontainrar i stället för att börja från början. Du kan läsa mer om containrarna och deras parametrar här. Den här demonstrationen använder mallen som tillhandahålls för att distribuera OPC PLC-servercontainerinstanser till Azure.

Gå till readme-exemplet för Azure IoT Edge OPC PLC och välj Distribuera till Azure.

Välj Redigera mall och gå till rad 172. Ersätt hela raden med följande kod för att lägga till nödvändiga flaggor för att distribuera önskade OPC PLC-servrar:

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

Du kan läsa mer om parametrarna i readme-filen.

Spara mallen och fyll i projekt- och instansinformationen. För Number of Simulationsanger du 2 för att köra två OPC PLC-servrar.
Välj Granska och skapa och sedan Skapa för att distribuera dina servrar i Azure.

Nu har du skapat två OPC UA PLC-servrar, var och en med en snabb PLC-nod, som genererar ett osignerat heltal med lägre gräns = 65 och övre gräns = 85 med en hastighet av 1.

Kör Akri

Kontrollera att OPC UA-servrarna körs genom att kontrollera att containerinstanserna har startats på din Azure Portal.
För att Akri ska kunna identifiera servrarna korrekt anger du rätt identifierings-URL:er när du installerar Akri.

Identifierings-URL:er visas som opc.tcp://<FQDN>:50000/. För att hämta FQDN för dina OPC PLC-servrar går du till dina distributioner i Azure så ser du det fullständiga domännamnet. Kopiera och klistra in det fullständiga domännamnet i identifierings-URL:erna för varje server.
Lägg till Akri-helmdiagrammen om du inte redan har gjort det:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Om du redan har lagt till Akri Helm-diagrammet tidigare uppdaterar du lagringsplatsen för den senaste versionen:
```
helm repo update
```

Installera Akri med Helm. När du installerar Akri anger du att du vill distribuera OPC UA-identifieringshanterare genom att ange helm-värdet opcua.discovery.enabled=true.

I det här scenariot anger du och NamespaceIndex för Identifier det NodeID som du vill att de asynkrona meddelandeköerna ska övervaka. I det här fallet är det temperaturvariabeln som skapades tidigare, som har en Identifier av FastUInt1 och NamespaceIndex2.

Se till att ersätta opcua.configuration.discoveryDetails.discoveryUrls med de URL:er som du fick i föregående steg:

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

Anteckning

FastUInt1 är identifieraren för den snabbt föränderliga noden som tillhandahålls av OPC PLC-servern.

Läs mer om konfigurationsinställningarna för OPC UA här.

När Akri har installerats identifierar Akri-agenten de två servrarna och skapar en instans för varje server. Se två asynkrona poddar snurra upp, en för varje server:
```
kubectl get pods -o wide --watch
```
Du kan också se till att Akris övervakningspodd har anslutits till OPC UA-servern:
```
kubectl logs <name of OPC UA monitoring pod>
```
Så här inspekterar du fler av elementen i Akri:
- Kör kubectl get crdoch du bör se CRD:erna i listan.
- Kör kubectl get akricoch du bör se akri-opcua-monitoring.
- Om OPC PLC-servrarna identifierades och poddarna knoppades upp kan du se instanserna genom att köra kubectl get akriioch du kan granska ytterligare genom att köra kubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Distribuera en webbapp för avvikelseidentifiering som slutkonsument av asynkrona meddelandeköer

Ett exempel på ett webbprogram för avvikelseidentifiering skapades för den här demonstrationen från slutpunkt till slutpunkt. Den har en gRPC-stub som anropar mäklarens gRPC-tjänster och får det senaste temperaturvärdet. Det avgör sedan om det här värdet är en avvikare till datauppsättningen med hjälp av strategin Local Outlier Factor. Datamängden är helt enkelt en CSV-fil där talen mellan 70 och 80 upprepas flera gånger. Därför kommer alla värden som ligger betydligt utanför detta intervall att ses som avvikande värden. Webbprogrammet fungerar som en logg som visar alla temperaturvärden och adressen till den OPC UA-server som skickade värdena. Den visar avvikelsevärden i rött. Avvikelserna har alltid värdet 120 på grund av hur DoSimulation funktionen konfigureras på OPC UA-servrarna.

Distribuera appen för avvikelseidentifiering och watch en podd som startas för appen:

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

kubectl get pods -o wide --watch

När poddarna körs hämtar du nod-IP-adressen och appens tjänstportnummer:
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Navigera till http://<NODE IP>:<SERVICE PORT NUM>/. Det tar några sekunder för webbplatsen att läsas in. Sedan bör du se en logg över temperaturvärdena, som uppdateras med några sekunders mellanrum. Observera hur värdena kommer från två olika identifierings-URL:er, särskilt de för var och en av de två OPC UA-servrarna.

Valfritt: certifikat för OPC UA-servern och asynkron meddelandekö

Det här är en valfri procedur som du kan använda för att prova Akri med certifikat för ökad säkerhet. Följ de här stegen för att distribuera OPC PLC-servrar med säkerhet och skapa en Kubernetes-hemlighet som kan användas för att autentisera servern och asynkron meddelandekö.

Skapa OPC UA-servrar med säkerhet

Gå till readme-exemplet för Azure IoT Edge OPC PLC och välj Distribuera till Azure.

Välj Redigera mall och gå till rad 172. Ersätt hela raden med följande kod för att lägga till nödvändiga flaggor för att distribuera önskade OPC PLC-servrar:

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

Under avsnittet resources lägger du till följande kod i det tredje properties avsnittet (rad 167) (samma nivå som image, command, portsosv.):

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

Lägg sedan till följande kod i det andra avsnittet "properties" (rad 163) (samma nivå som containers):

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

Spara mallen och fyll i projekt- och instansinformationen. För Number of Simulationsanger du 2 för att köra två OPC PLC-servrar.
Välj Granska och skapa och välj sedan Skapa för att distribuera dina servrar i Azure.

Nu har du skapat två OPC UA PLC-servrar, var och en med en snabb PLC-nod, som genererar ett osignerat heltal med lägre gräns = 65 och övre gräns = 85 med en hastighet av 1.

Skapa X.509 v3-certifikat

Skapa tre OPC UA-kompatibla X.509v3-certifikat (ett för den asynkrona meddelandekön och ett för varje server) och se till att certifikatet innehåller nödvändiga komponenter, till exempel en program-URI.

Krav för certifikat:

De bör alla vara signerade av en gemensam certifikatutfärdare (CA), och signeringsalgoritmerna för alla certifikat ska vara SHA256.
Nyckelstorleken måste också vara större än eller lika med 2048 bitar.
DNS för servercertifikat och AkriBroker-certifikat bör innehålla FQDN för den OPC UA-servercontainerinstans som skapats (gå till Steg 3 i Kör Akri för att lära dig hur du hämtar FQDN).
OPC UA-servercertifikatet ska namnges OpcPlc (i certifikatgenererande termer) CN=OpcPlcoch Akri Broker-certifikatet ska namnges AkriBroker (CN=AkriBroker) (det finns inga krav för CA-namnet).

Det finns många verktyg för att generera rätt certifikat för OPC UA, till exempel OPC Foundations certifikatgenerator eller OpenSSL. OPC Foundations certifikatgenerator kan vara ett bekvämare alternativ, medan OpenSSL ger mer utrymme för anpassning.

Om du väljer att använda OPC Foundations certifikatgenerator följer du dessa steg för att skapa:

Installera Perl.
Ladda ned .zip-filen eller klona OPC Foundations certifikatgenerators lagringsplats (Misc-Tools).
Kör build_certificate-generator.bat från Kommandotolken för Visual Studio-utvecklare (Visual Studio 2022 rekommenderas).
Skapa Opc.Ua.CertificateGenerator en lösning från Visual Studio 2022.
Kontrollera om Opc.Ua.CertificateGenerator.exe har skapats i build/Debug/Opc.Ua.CertificateGenerator katalogen.

Använd följande exempelkommandon för att skapa certifikat. Fler alternativ finns i Misc-Tools :

Self-Signed CA:

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

OPC UA-servercertifikat:

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

Akri Broker-certifikat:

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

Skapa en .crl fil för CA med OpenSSL (endast om du skapade CA från generatorn, vilket skulle sakna .crl filen).

Om du väljer att använda OpenSSL finns här en lista med referenser:

Skapa en Opcua-broker-credentials Kubernetes-hemlighet

OPC UA-klientcertifikatet skickas till OPC UA-övervakningskoordinatorn som en Kubernetes-hemlighet monterad som en volym.

Skapa en Kubernetes-hemlighet som projicerar varje certifikat/crl/privat nyckel med det förväntade nyckelnamnet (client_certificate, client_key, ca_certificateoch ca_crl). Ange filsökvägarna så att de pekar på de autentiseringsuppgifter som skapades i föregående avsnitt:

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

Certifikatet monteras på volymen credentials på mountPath /etc/opcua-certs/client-pki, som du ser i OPC UA-konfigurations helm-mallen. Den här sökvägen är där asynkrona meddelandeköer förväntar sig att hitta certifikaten.

Montera mappen med certifikat till ACI:et

Följ de här anvisningarna för att skapa en Azure-filresurs.

När du har skapat Azure-filresursen och certifikaten laddar du upp CA- och OPC UA-servercertifikaten till filresursen enligt beskrivningen.

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

Anteckning

Eftersom vi har lagt till en säkerhetsflagga i mallen genereras ett godtyckligt certifikat i filresursen. Du kan ta bort alla oidentifierade certifikat i filresursen (mappsökvägarna bör se exakt likadana ut som i föregående diagram).

När du har följt de här stegen för säkerhet klickar du på Starta om på containerinstansen för att uppdatera den och köra den med de monterade certifikaten.

Kör Akri och distribuera webbapp

Följ föregående avsnitt för att köra Akri och identifiera dina servrar, men lägg nu till en rad --set opcua.configuration.mountCertificates='true' i slutet av kommandot. Ersätt opcua.configuration.discoveryDetails.discoveryUrls med url:erna som hittades från 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'

Härifrån kan du följa avsnittet om hur du distribuerar en webbapp för avvikelseidentifiering som slutkonsument av asynkrona meddelandeköer för att se dina OPC PLC-värden på din webbsida.

Rensa

Ta bort programmet för avvikelseidentifiering:

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

Avinstallera Akri från klustret.
```
helm delete akri
```
Ta bort OPC UA-serverdistributionen genom att gå till containerinstansen och välj sedan Ta bort i Azure Portal.

Nästa steg

Översikt över AKS Edge Essentials

Dela via