Descobrir servidores OPC UA com o Akri

Artigo
10/27/2023

O Akri é uma interface de recursos do Kubernetes que lhe permite expor facilmente dispositivos de folha heterogéneos (como câmaras IP e dispositivos USB) como recursos num cluster do Kubernetes. O Akri deteta continuamente nós que têm acesso a estes dispositivos para agendar cargas de trabalho com base nos mesmos. O Akri é um projeto de sandbox CNCF criado para a periferia, que lida com o aspeto dinâmico e o desaparecimento de dispositivos de folha. Atualmente, suporta protocolos OPC UA, ONVIF e udev, mas também pode implementar processadores de protocolos personalizados fornecidos pelo modelo. Leia mais sobre o Akri aqui.

Este artigo descreve como pode implementar contentores de servidor OPC PLC de exemplo no Azure e detetá-los ao implementar o Akri no cluster do AKS Edge Essentials. A OPC UA é um protocolo de comunicação para a automatização industrial. É uma tecnologia de cliente/servidor que inclui uma arquitetura de segurança e comunicação. Se, em algum momento da demonstração, quiser aprofundar a OPC UA ou clarificar um termo, consulte as especificações online da OPC UA.

Esta demonstração ajuda-o a começar a utilizar o Akri para detetar servidores OPC UA e utilizá-los através de um mediador que contém um cliente OPC UA. Especificamente, foi criada uma configuração do Akri chamada Monitorização OPC UA para este cenário. Esta configuração mostra como pode utilizar o Akri para detetar valores de anomalias de uma variável OPC UA específica. Para tal, os clientes OPC UA nos mediadores subscrevem essa variável e servem o seu valor sobre gRPC para que uma aplicação Web de deteção de anomalias consuma. Pode utilizar esta configuração para monitorizar um barómetro, um detetor de CO e muito mais. No entanto, para este exemplo, a variável OPC UA representa os valores PLC (controlador lógico programável) para a temperatura de um termóstato. Qualquer valor fora do intervalo de 70 a 80 graus é uma anomalia. Além disso, se quiser utilizar certificados para segurança, avance para a secção no final.

Pré-requisitos

Cluster do AKS Edge Essentials em execução.
Subscrição do Azure e um grupo de recursos para implementar servidores OPC PLC.
O Akri só funciona no Linux: utilize nós linux para este exercício.

Criar servidores OPC UA

Agora, crie alguns servidores OPC UA PLC para detetar. Em vez de começar do zero, implemente contentores de servidor OPC PLC. Pode ler mais sobre os contentores e os respetivos parâmetros aqui. Esta demonstração utiliza o modelo fornecido para implementar instâncias de contentor do servidor OPC PLC no Azure.

Aceda ao readme do exemplo OPC PLC do Azure IoT Edge e selecione Implementar no Azure.
Selecione Editar Modelo e navegue para a linha 172. Substitua toda a linha pelo seguinte código, para adicionar os sinalizadores necessários para implementar os servidores OPC PLC pretendidos:
```
"[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')]"
```
Pode ler mais sobre os parâmetros no ficheiro readme.
Guarde o modelo e preencha os detalhes do projeto e da instância. Para Number of Simulations, especifique 2 para executar dois servidores OPC PLC.
Selecione Rever e Criar e, em seguida, Criar para implementar os servidores no Azure.

Criou com êxito dois servidores OPC UA PLC, cada um com um nó PLC rápido, o que gera um número inteiro não assinado com limite inferior = 65 e limite superior = 85 a uma taxa de 1.

Executar o Akri

Certifique-se de que os servidores OPC UA estão em execução ao verificar se as instâncias de contentor foram iniciadas no seu portal do Azure.
Para que o Akri descubra corretamente os servidores, especifique os URLs de deteção corretos ao instalar o Akri.

Os URLs de deteção aparecem como opc.tcp://<FQDN>:50000/. Para obter os FQDNs dos seus servidores OPC PLC, navegue para as suas implementações no Azure e verá o FQDN. Copie e cole o FQDN nos URLs de deteção de cada servidor.
Adicione os gráficos helm do Akri, se ainda não o fez:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Se já tiver adicionado anteriormente o gráfico helm do Akri, atualize o repositório para obter a compilação mais recente:
```
helm repo update
```

Instale o Akri com o Helm. Quando instalar o Akri, especifique que pretende implementar os processadores de deteção OPC UA ao definir o valor opcua.discovery.enabled=truedo helm .

Neste cenário, especifique o Identifier e NamespaceIndex do NodeID que pretende que os mediadores monitorizem. Neste caso, é a variável de temperatura criada anteriormente, que tem um Identifier de FastUInt1 e NamespaceIndex de 2.

Certifique-se de que substitui os opcua.configuration.discoveryDetails.discoveryUrls pelos URLs que obteve no passo anterior:

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 é o identificador do nó em rápida alteração fornecido pelo servidor OPC PLC.

Saiba mais sobre as definições de configuração do OPC UA aqui.

Assim que o Akri estiver instalado, o agente do Akri deteta os dois servidores e cria uma instância para cada servidor. Veja dois pods de mediador a girar, um para cada servidor:
```
kubectl get pods -o wide --watch
```
Também pode garantir que o pod de monitorização do Akri se ligou com êxito ao servidor OPC UA:
```
kubectl logs <name of OPC UA monitoring pod>
```
Para inspecionar mais elementos do Akri:
- Execute kubectl get crde deverá ver os CRDs listados.
- Execute kubectl get akrice deverá ver akri-opcua-monitoring.
- Se os servidores OPC PLC foram detetados e os pods foram ativados, pode ver as instâncias ao executar kubectl get akriie pode inspecionar mais ao executar kubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Implementar uma aplicação Web de deteção de anomalias como consumidor final dos mediadores

Foi criada uma aplicação Web de deteção de anomalias de exemplo para esta demonstração ponto a ponto. Tem um stub gRPC que chama os serviços gRPC dos mediadores, obtendo o valor de temperatura mais recente. Em seguida, determina se este valor é um valor atípico para o conjunto de dados com a estratégia Fator Outlier Local. O conjunto de dados é simplesmente um ficheiro CSV com os números entre 70 e 80 repetidos várias vezes; portanto, qualquer valor significativamente fora deste intervalo será visto como um valor atípico. A aplicação Web serve como um registo, apresentando todos os valores de temperatura e o endereço do servidor OPC UA que enviou os valores. Mostra valores de anomalias a vermelho. As anomalias têm sempre um valor de 120 devido à forma como a DoSimulation função é configurada nos servidores OPC UA.

Implemente a aplicação de deteção de anomalias e watch um pod gira para a aplicação:

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

kubectl get pods -o wide --watch

Assim que os pods estiverem em execução, obtenha o IP do nó e o número da porta de serviço da aplicação:
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Navegue para http://<NODE IP>:<SERVICE PORT NUM>/. O carregamento do site demora alguns segundos e, em seguida, deverá ver um registo dos valores de temperatura, que é atualizado a cada poucos segundos. Tenha em atenção como os valores provêm de dois URLs de deteção diferentes, especificamente os de cada um dos dois servidores OPC UA.

Opcional: certificados para o servidor e mediador OPC UA

Este é um procedimento opcional que pode utilizar para experimentar o Akri com certificados para maior segurança. Siga estes passos para implementar servidores OPC PLC com segurança e criar um segredo do Kubernetes que pode ser utilizado para autenticar o servidor e o mediador.

Criar servidores OPC UA com segurança

Aceda ao readme do exemplo OPC PLC do Azure IoT Edge e selecione Implementar no Azure.

Selecione Editar Modelo e navegue para a linha 172. Substitua toda a linha pelo seguinte código para adicionar os sinalizadores necessários para implementar os servidores OPC PLC pretendidos:

"[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 Na secção, adicione o seguinte código dentro da terceira properties secção (linha 167) (o mesmo nível que image, command, ports, etc.):

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

Em seguida, adicione o seguinte código dentro da segunda secção "propriedades" (linha 163) (o mesmo nível que containers):

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

Guarde o modelo e preencha os detalhes do projeto e da instância. Para Number of Simulations, especifique 2 para executar dois servidores OPC PLC.
Selecione Rever e Criar e, em seguida, selecione Criar para implementar os servidores no Azure.

Criar certificados X.509 v3

Crie três certificados X.509v3 compatíveis com OPC UA (um para o mediador e outro para cada servidor), garantindo que o certificado contém os componentes necessários, como um URI de aplicação.

Requisitos para certificados:

Todos devem ser assinados por uma Autoridade de Certificação (AC) comum e os algoritmos de assinatura de todos os certificados devem ser SHA256.
O tamanho da chave também tem de ser maior ou igual a 2048 bits.
O DNS de certificados de servidor e o certificado AkriBroker devem conter o FQDN da instância de contentor do servidor OPC UA criada (aceda ao Passo 3 da Execução do Akri para saber como obter o FQDN).
O certificado do servidor OPC UA deve ser nomeado OpcPlc (em termos geradores de certificados) CN=OpcPlce o certificado de mediador do Akri deve ser nomeado AkriBroker (CN=AkriBroker) (não existem requisitos para o nome da AC).

Existem muitas ferramentas para gerar certificados adequados para o OPC UA, como o Gerador de Certificados da Fundação OPC ou o OpenSSL. O Gerador de Certificados da Fundação OPC pode ser uma opção mais conveniente, enquanto o OpenSSL fornece mais espaço para personalização.

Se optar por utilizar o Gerador de Certificados do OPC Foundation, siga estes passos para criar:

Instale o Perl.
Transfira o ficheiro .zip ou clone o repositório gerador de certificados (Misc-Tools) da Fundação OPC .
Execute build_certificate-generator.bat a partir da linha de comandos para programadores do Visual Studio (recomenda-se o Visual Studio 2022).
Crie Opc.Ua.CertificateGenerator uma solução a partir do Visual Studio 2022.
Verifique se Opc.Ua.CertificateGenerator.exe foi criado com êxito no build/Debug/Opc.Ua.CertificateGenerator diretório.

Utilize os seguintes comandos de exemplo para criar certificados. Consulte Misc-Tools para obter mais opções:

Self-Signed AC:

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

Certificado de servidor OPC UA:

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

Certificado de mediador do Akri:

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

Crie um .crl ficheiro para a AC com o OpenSSL (apenas se tiver criado AC a partir do gerador, o que estaria em falta no .crl ficheiro).

Se optar por utilizar o OpenSSL, eis uma lista de referências:

Criar um segredo do Kubernetes opcua-broker-credentials

O certificado de cliente OPC UA é transmitido para o mediador de monitorização OPC UA como um segredo do Kubernetes montado como um volume.

Crie um segredo do Kubernetes, projetando cada certificado/crl/chave privada com o nome de chave esperado (client_certificate, client_key, ca_certificatee ca_crl). Especifique os caminhos de ficheiro para que apontem para as credenciais criadas na secção anterior:

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

O certificado é montado no volume credentials no /etc/opcua-certs mountPath /client-pki, conforme mostrado no modelo helm de configuração OPC UA. Este caminho é onde os mediadores esperam encontrar os certificados.

Montar a pasta de certificados no ACI

Siga estas instruções para criar uma partilha de ficheiros do Azure.

Depois de criar a partilha de ficheiros e certificados do Azure, carregue os certificados de servidor OPC UA e AC para a partilha de ficheiros, conforme descrito.

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

Nota

Uma vez que adicionámos um sinalizador para segurança no modelo, isto faz com que seja gerado um certificado arbitrário na partilha de ficheiros. Pode eliminar quaisquer certificados não identificados na partilha de ficheiros (os caminhos da pasta devem ter exatamente o mesmo aspeto que o diagrama anterior).

Depois de seguir estes passos para segurança, clique em Reiniciar na instância do contentor para atualizá-la e executar com os certificados montados.

Executar o Akri e implementar a aplicação Web

Siga a secção anterior para executar o Akri e descobrir os seus servidores, mas agora adicione uma linha --set opcua.configuration.mountCertificates='true' ao final do comando. Certifique-se de que substitui opcua.configuration.discoveryDetails.discoveryUrls pelos URLs encontrados no portal do 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'

A partir daqui, pode seguir a secção sobre como implementar uma aplicação Web de deteção de anomalias como consumidor final dos mediadores para ver os seus valores OPC PLC na sua página Web.

Limpeza

Elimine a aplicação de deteção de anomalias:

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

Desinstale o Akri do cluster.
```
helm delete akri
```
Elimine a implementação do servidor OPC UA ao navegar para a instância de contentor e, em seguida, selecione Eliminar no portal do Azure.

Passos seguintes

Descrição geral do AKS Edge Essentials

Partilhar via