Individuare i server OPC UA con Akri

Articolo
10/27/2023

Akri è un'interfaccia delle risorse Kubernetes che consente di esporre facilmente dispositivi foglia eterogeni (ad esempio telecamere IP e dispositivi USB) come risorse in un cluster Kubernetes. Akri rileva continuamente i nodi che hanno accesso a questi dispositivi per pianificare i carichi di lavoro in base a essi. Akri è un progetto sandbox CNCF realizzato per il bordo, gestendo l'aspetto dinamico e la scomparsa di dispositivi foglia. Attualmente supporta protocolli OPC UA, ONVIF e udev, ma è anche possibile implementare gestori di protocolli personalizzati forniti dal modello. Altre informazioni su Akri sono disponibili qui.

Questo articolo descrive come distribuire contenitori server OPC PLC di esempio in Azure e individuarli distribuendo Akri nel cluster AKS Edge Essentials. OPC UA è un protocollo di comunicazione per l'automazione industriale. È una tecnologia client/server che include un framework di sicurezza e comunicazione. Se in qualsiasi momento nella demo si vuole approfondire OPC UA o chiarire un termine, vedere le specifiche OPC UA online.

Questa demo consente di iniziare a usare Akri per individuare i server OPC UA e usarli tramite un broker che contiene un client OPC UA. In particolare, è stata creata una configurazione di Akri denominata Monitoraggio UA OPC per questo scenario. Questa configurazione illustra come usare Akri per rilevare valori anomali di una variabile OPC UA specifica. A tale scopo, i client OPC UA nei broker sottoscrivono tale variabile e servono il relativo valore su gRPC per un'applicazione Web di rilevamento anomalie da utilizzare. È possibile usare questa configurazione per monitorare un barometro, un rilevatore CO e altro ancora. Tuttavia, per questo esempio, la variabile OPC UA rappresenta i valori PLC (controller di logica programmabile) per la temperatura di un termostato. Qualsiasi valore all'esterno dell'intervallo di 70-80 gradi è un'anomalia. Inoltre, se si desidera usare i certificati per la sicurezza, passare alla sezione alla fine.

Prerequisiti

Cluster Azure Kubernetes Edge Essentials in esecuzione e in esecuzione.
Sottoscrizione di Azure e un gruppo di risorse a cui distribuire server OPC PLC.
Akri funziona solo in Linux: usare nodi Linux per questo esercizio.

Creare server OPC UA

Creare ora alcuni server OPC UA PLC da individuare. Invece di iniziare da zero, distribuire contenitori server OPC PLC. Per altre informazioni sui contenitori e sui relativi parametri, vedere qui. Questa demo usa il modello fornito per distribuire istanze del contenitore server OPC PLC in Azure.

Passare all'esempio di Azure IoT Edge OPC PLC e selezionare Distribuisci in Azure.
Selezionare Modifica modello e passare alla riga 172. Sostituire l'intera riga con il codice seguente per aggiungere i flag necessari per distribuire i server OPC PLC desiderati:
```
"[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')]"
```
È possibile leggere altre informazioni sui parametri nel file readme.
Salvare il modello e compilare i dettagli del progetto e dell'istanza. Per Number of Simulations, specificare 2 per eseguire due server OPC PLC.
Selezionare Rivedi e crea e quindi crea per distribuire i server in Azure.

È stato creato correttamente due server OPC UA PLC, ognuno con un nodo PLC veloce, che genera un intero senza segno con un limite inferiore = 65 e limite superiore = 85 a una velocità di 1.

Eseguire Akri

Assicurarsi che i server OPC UA vengano eseguiti controllando che le istanze del contenitore siano state avviate nel portale di Azure.
Per individuare correttamente i server, specificare gli URL di individuazione corretti durante l'installazione di Akri.

Gli URL di individuazione vengono visualizzati come opc.tcp://<FQDN>:50000/. Per ottenere i FQDN dei server OPC PLC, passare alle distribuzioni in Azure e verrà visualizzato il nome di dominio completo. Copiare e incollare il nome di dominio completo negli URL di individuazione per ogni server.
Aggiungere i grafici helm Akri, se non sono già stati:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Se in precedenza è stato aggiunto il grafico helm Akri, aggiornare il repository per la build più recente:
```
helm repo update
```

Installare Akri usando Helm. Quando si installa Akri, specificare che si vuole distribuire i gestori di individuazione OPC UA impostando il valore opcua.discovery.enabled=truehelm .

In questo scenario specificare l'oggetto Identifier e NamespaceIndex del NodeID da monitorare dai broker. In questo caso, questa è la variabile di temperatura creata in precedenza, che ha un Identifier oggetto e FastUInt1NamespaceIndex di 2.

Assicurarsi di sostituire con gli opcua.configuration.discoveryDetails.discoveryUrls URL ottenuti nel passaggio precedente:

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

Nota

FastUInt1 è l'identificatore del nodo a modifica rapida fornito dal server OPC PLC.

Altre informazioni sulle impostazioni di configurazione OPC UA sono disponibili qui.

Dopo aver installato Akri, l'agente Akri individua i due server e crea un'istanza per ogni server. Guardare due pod broker spin up, uno per ogni server:
```
kubectl get pods -o wide --watch
```
È anche possibile assicurarsi che il pod di monitoraggio di Akri sia stato connesso correttamente al server OPC UA:
```
kubectl logs <name of OPC UA monitoring pod>
```
Per esaminare altri elementi di Akri:
- Eseguire e visualizzare kubectl get crdi CRD elencati.
- Eseguire kubectl get akrice dovrebbe essere visualizzato akri-opcua-monitoring.
- Se i server OPC PLC sono stati individuati e i pod sono stati spostati, è possibile visualizzare le istanze eseguendo e è possibile esaminare ulteriormente eseguendo kubectl get akriikubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Distribuire un'applicazione Web di rilevamento anomalie come consumer finale dei broker

Per questa demo end-to-end è stata creata un'applicazione Web di rilevamento anomalie di esempio. Ha uno stub gRPC che chiama i servizi gRPC dei broker, ottenendo il valore di temperatura più recente. Determina quindi se questo valore è un outlier al set di dati usando la strategia Local Outlier Factor. Il set di dati è semplicemente un file CSV con i numeri tra 70 e 80 ripetuti più volte; pertanto, qualsiasi valore all'esterno di questo intervallo verrà considerato come outlier. L'applicazione Web funge da log, visualizzando tutti i valori di temperatura e l'indirizzo del server OPC UA che ha inviato i valori. Mostra valori anomali in rosso. Le anomalie hanno sempre un valore pari a 120 a causa della configurazione della DoSimulation funzione nei server OPC UA.

Distribuire l'app di rilevamento anomalie e watch un pod spin up per l'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

Dopo aver eseguito i pod, ottenere l'INDIRIZZO IP del nodo e il numero di porta del servizio dell'app:
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Accedere a http://<NODE IP>:<SERVICE PORT NUM>/. Il caricamento del sito richiede alcuni secondi, quindi dovrebbe essere visualizzato un log dei valori di temperatura, che viene aggiornato ogni pochi secondi. Si noti come i valori provengono da due URL di individuazione diversi, in particolare quelli per ognuno dei due server OPC UA.

Facoltativo: certificati per il server OPC UA e il broker

Questa procedura facoltativa consente di provare Akri con certificati per la sicurezza aggiunta. Seguire questa procedura per distribuire server OPC PLC con sicurezza e creare un segreto Kubernetes che può essere usato per autenticare il server e il broker.

Creare server OPC UA con sicurezza

Passare all'esempio di Azure IoT Edge OPC PLC e selezionare Distribuisci in Azure.

Selezionare Modifica modello e passare alla riga 172. Sostituire l'intera riga con il codice seguente per aggiungere i flag necessari per distribuire i server OPC PLC desiderati:

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

resources Nella sezione aggiungere il codice seguente all'interno della terza properties sezione (riga 167) (stesso livello di image, command, portse così via):

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

Aggiungere quindi il codice seguente all'interno della seconda sezione "proprietà" (riga 163) (stesso livello di containers):

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

Salvare il modello e compilare i dettagli del progetto e dell'istanza. Per Number of Simulations, specificare 2 per eseguire due server OPC PLC.
Selezionare Rivedi e Crea e quindi crea per distribuire i server in Azure.

Creare certificati X.509 v3

Creare tre certificati OPC UA conformi X.509v3 (uno per il broker e uno per ogni server), assicurandosi che il certificato contenga i componenti necessari, ad esempio un URI dell'applicazione.

Requisiti per i certificati:

Devono essere firmati da un'autorità di certificazione comune e gli algoritmi di firma per tutti i certificati devono essere SHA256.
Anche le dimensioni della chiave devono essere maggiori o uguali a 2048 bit.
Il DNS dei certificati server e del certificato AkriBroker deve contenere il nome di dominio completo dell'istanza del contenitore del server OPC UA creata (passare al passaggio 3 di Run Akri per informazioni su come ottenere il nome di dominio completo).
Il certificato server OPC UA deve essere denominato OpcPlc (in termini di generazione di certificati, CN=OpcPlc) e il certificato broker Akri deve essere denominato AkriBroker () (CN=AkriBrokernon sono previsti requisiti per il nome della CA).

Esistono molti strumenti per generare certificati appropriati per OPC UA, ad esempio il generatore di certificati OPC Foundation o OpenSSL. Il generatore di certificati di OPC Foundation può essere un'opzione più conveniente, mentre OpenSSL offre più spazio per la personalizzazione.

Se si sceglie di usare il generatore di certificati di OPC Foundation, seguire questa procedura per compilare:

Installare Perl.
Scaricare il file di .zip o clonare il repository generatore di certificati di OPC Foundation (Misc-Tools).
Eseguire build_certificate-generator.bat dal prompt dei comandi per gli sviluppatori di Visual Studio (è consigliato Visual Studio 2022).
Compilare Opc.Ua.CertificateGenerator una soluzione da Visual Studio 2022.
Controllare se Opc.Ua.CertificateGenerator.exe la directory è stata compilata correttamente build/Debug/Opc.Ua.CertificateGenerator .

Usare i comandi di esempio seguenti per creare certificati. Per altre opzioni, vedere Misc-Tools :

Self-Signed CA:

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

Certificato del server OPC UA:

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

Certificato broker Akri:

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

Creare un file per l'autorità .crl di certificazione usando OpenSSL (solo se è stata creata l'autorità di certificazione dal generatore, che sarebbe mancante nel .crl file).

Se si sceglie di usare OpenSSL, ecco un elenco di riferimenti:

Creare un segreto Kubernetes opcua-broker-credentials

Il certificato client OPC UA viene passato al broker di monitoraggio OPC UA come segreto Kubernetes montato come volume.

Creare un segreto Kubernetes, proiettando ogni certificato/crl/chiave privata con il nome della chiave previsto (client_certificate, client_key, ca_certificatee ca_crl). Specificare i percorsi dei file in modo che puntino alle credenziali create nella sezione precedente:

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

Il certificato viene montato nel volume credentials in mountPath /etc/opcua-certs/client-pki, come illustrato nel modello helm di configurazione OPC UA. Questo percorso è il percorso in cui i broker si aspettano di trovare i certificati.

Montare la cartella dei certificati nell'ACI

Seguire queste istruzioni per creare una condivisione file di Azure.

Dopo aver creato la condivisione file e i certificati di Azure, caricare i certificati del server CA e OPC UA nella condivisione file come descritto.

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

Nota

Poiché è stato aggiunto un flag per la sicurezza nel modello, questo comporta la generazione di un certificato arbitrario nella condivisione file. È possibile eliminare tutti i certificati non identificati nella condivisione file . I percorsi delle cartelle dovrebbero essere esattamente uguali a quelli del diagramma precedente.

Dopo aver seguito questi passaggi per la sicurezza, fare clic su Riavvia nell'istanza del contenitore per aggiornarla ed eseguirla con i certificati montati.

Eseguire Akri e distribuire l'app Web

Seguire la sezione precedente per eseguire Akri e individuare i server, ma ora aggiungere una riga --set opcua.configuration.mountCertificates='true' alla fine del comando. Assicurarsi di sostituire opcua.configuration.discoveryDetails.discoveryUrls con gli URL trovati dal portale di 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'

Da qui è possibile seguire la sezione sulla distribuzione di un'applicazione Web di rilevamento anomalie come consumer finale dei broker per visualizzare i valori OPC PLC nella pagina Web.

Eseguire la pulizia

Eliminare l'applicazione di rilevamento anomalie:

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

Disinstallare Akri dal cluster.
```
helm delete akri
```
Eliminare la distribuzione del server OPC UA passando all'istanza del contenitore e quindi selezionare Elimina nel portale di Azure.

Passaggi successivi

Panoramica di AKS Edge Essentials

Condividi tramite