Descobrir servidores OPC UA com o Akri

Artigo
10/17/2023

O Akri é uma interface de recurso do Kubernetes que permite expor facilmente dispositivos folha heterogêneos (como câmeras IP e dispositivos USB) como recursos em um cluster do Kubernetes. O Akri detecta continuamente nós que têm acesso a esses dispositivos para agendar cargas de trabalho com base neles. Akri é um projeto de área restrita CNCF feito para a borda, tratando a aparência dinâmica e o desaparecimento de dispositivos folha. Atualmente, ele dá suporte a protocolos OPC UA, ONVIF e udev, mas você também pode implementar manipuladores de protocolo personalizados fornecidos pelo modelo. Leia mais sobre Akri aqui.

Este artigo descreve como você pode implantar contêineres de servidor OPC PLC de exemplo no Azure e descobri-los implantando o Akri em seu cluster do AKS Edge Essentials. O OPC UA é um protocolo de comunicação para automação industrial. É uma tecnologia de cliente/servidor que vem com uma estrutura de segurança e comunicação. Se em qualquer momento da demonstração, você quiser se aprofundar no OPC UA ou esclarecer um termo, consulte as especificações online do OPC UA.

Essa demonstração ajuda você a começar a usar o Akri para descobrir servidores OPC UA e usá-los por meio de um agente que contém um cliente OPC UA. Especificamente, uma configuração do Akri chamada Monitoramento do OPC UA foi criada para esse cenário. Essa configuração mostra como você pode usar o Akri para detectar valores de anomalias de uma variável específica do OPC UA. Para fazer isso, os clientes OPC UA nos agentes assinam essa variável e atendem seu valor sobre gRPC para um aplicativo Web de detecção de anomalias consumir. Você pode usar essa configuração para monitorar um barômetro, um detector 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 termostato. Qualquer valor fora do intervalo de 70 a 80 graus é uma anomalia. Além disso, se você quiser usar certificados para segurança, pule para a seção no final.

Pré-requisitos

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

Criar servidores OPC UA

Agora, crie alguns servidores OPC UA PLC para descobrir. Em vez de começar do zero, implante contêineres de servidor OPC PLC. Você pode ler mais sobre os contêineres e seus parâmetros aqui. Essa demonstração usa o modelo fornecido para implantar instâncias de contêiner do servidor OPC PLC no Azure.

Vá para o leiame do exemplo OPC PLC do IoT Edge do Azure e selecione Implantar no Azure.
Selecione Editar Modelo e navegue até a linha 172. Substitua toda a linha pelo código a seguir para adicionar os sinalizadores necessários para implantar os servidores OPC PLC desejados:
```
"[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')]"
```
Você pode ler mais sobre os parâmetros no arquivo readme.
Salve 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 Examinar e Criar e, em seguida, Criar para implantar seus servidores no Azure.

Agora você criou com êxito dois servidores OPC UA PLC, cada um com um nó PLC rápido, que gera um inteiro sem sinal com limite inferior = 65 e limite superior = 85 a uma taxa de 1.

Executar a Akri

Verifique se os servidores OPC UA estão em execução verificando se as instâncias de contêiner foram iniciadas no portal do Azure.
Para que o Akri descubra os servidores corretamente, especifique as URLs de descoberta corretas ao instalar o Akri.

As URLs de descoberta aparecem como opc.tcp://<FQDN>:50000/. Para obter os FQDNs de seus servidores OPC PLC, navegue até suas implantações no Azure e você verá o FQDN. Copie e cole o FQDN em suas URLs de descoberta para cada servidor.
Adicione os gráficos do Helm do Akri, se você ainda não tiver:
```
helm repo add akri-helm-charts https://project-akri.github.io/akri/
```
Se você já adicionou o gráfico do Helm do Akri anteriormente, atualize seu repositório para a compilação mais recente:
```
helm repo update
```

Instale o Akri usando o Helm. Ao instalar o Akri, especifique que deseja implantar os manipuladores de descoberta do OPC UA definindo o valor opcua.discovery.enabled=truehelm .

Nesse cenário, especifique o Identifier e NamespaceIndex do NodeID que você deseja que os agentes monitorem. Nesse caso, essa é a variável de temperatura criada anteriormente, que tem um Identifier de FastUInt1 e NamespaceIndex de 2.

Substitua o opcua.configuration.discoveryDetails.discoveryUrls pelas URLs obtidas na etapa 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/" `

Observação

FastUInt1 é o identificador do nó de alteração rápida fornecido pelo servidor OPC PLC.

Saiba mais sobre as configurações do OPC UA aqui.

Depois que o Akri é instalado, o agente do Akri descobre os dois servidores e cria uma instância para cada servidor. Assista a dois pods de agente girarem, um para cada servidor:
```
kubectl get pods -o wide --watch
```
Você também pode garantir que o pod de monitoramento do Akri tenha se conectado com êxito ao servidor OPC UA:
```
kubectl logs <name of OPC UA monitoring pod>
```
Para inspecionar mais dos elementos de Akri:
- Execute kubectl get crde você deverá ver os CRDs listados.
- Execute kubectl get akrice você deverá ver akri-opcua-monitoring.
- Se os servidores OPC PLC foram descobertos e os pods girados, você pode ver as instâncias executando kubectl get akriie pode inspecionar mais executando kubectl get akrii akri-opcua-monitoring-<ID> -o yaml.

Implantar um aplicativo Web de detecção de anomalias como um consumidor final dos agentes

Um aplicativo Web de detecção de anomalias de exemplo foi criado para essa demonstração de ponta a ponta. Ele tem um stub gRPC que chama os serviços gRPC dos agentes, obtendo o valor de temperatura mais recente. Em seguida, ele determina se esse valor é uma exceção ao conjunto de dados usando a estratégia fator outlier local. O conjunto de dados é simplesmente um arquivo CSV com os números entre 70-80 repetidos várias vezes; portanto, qualquer valor significativamente fora desse intervalo será visto como uma exceção. O aplicativo Web serve como um log, exibindo todos os valores de temperatura e o endereço do servidor OPC UA que enviou os valores. Ele mostra valores de anomalias em vermelho. As anomalias sempre têm um valor de 120 devido à forma como a DoSimulation função é configurada nos servidores OPC UA.

Implante o aplicativo de detecção de anomalias e watch um giro de pod para o aplicativo:

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

kubectl get pods -o wide --watch

Depois que os pods estiverem em execução, obtenha o IP do nó e o número da porta de serviço do aplicativo:
```
Get-AKSEdgeNodeAddr
```
```
kubectl get svc
```
Navegue até http://<NODE IP>:<SERVICE PORT NUM>/. Leva alguns segundos para o site carregar e, em seguida, você deve ver um log dos valores de temperatura, que é atualizado a cada poucos segundos. Observe como os valores vêm de duas URLs de descoberta diferentes, especificamente as de cada um dos dois servidores OPC UA.

Opcional: certificados para o servidor E o agente do OPC UA

Este é um procedimento opcional que você pode usar para experimentar o Akri com certificados para maior segurança. Siga estas etapas para implantar servidores OPC PLC com segurança e criar um segredo do Kubernetes que pode ser usado para autenticar o servidor e o agente.

Criar servidores OPC UA com segurança

Vá para o leiame do exemplo OPC PLC do IoT Edge do Azure e selecione Implantar no Azure.

Selecione Editar Modelo e navegue até a linha 172. Substitua toda a linha pelo código a seguir para adicionar os sinalizadores necessários para implantar os servidores OPC PLC desejados:

"[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 seção , adicione o seguinte código dentro da terceira properties seção (linha 167) (mesmo nível imageque , command, portsetc.):

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

Em seguida, adicione o seguinte código na segunda seção "propriedades" (linha 163) (mesmo nível containersque ):

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

Salve 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 Examinar e Criar e, em seguida, selecione Criar para implantar seus servidores no Azure.

Agora você criou com êxito dois servidores OPC UA PLC, cada um com um nó PLC rápido, que gera um inteiro sem sinal com limite inferior = 65 e limite superior = 85 a uma taxa de 1.

Criar certificados X.509 v3

Crie três certificados X.509v3 compatíveis com OPC UA (um para o agente e outro para cada servidor), garantindo que o certificado contenha os componentes necessários, como um URI de aplicativo.

Requisitos para certificados:

Todos eles devem ser assinados por uma AC (Autoridade de Certificação) comum, e os algoritmos de assinatura para todos os certificados devem ser SHA256.
O tamanho da chave também deve 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 contêiner do servidor OPC UA criada (vá para a Etapa 3 do Run Akri para saber como obter o FQDN).
O certificado do servidor OPC UA deve ser nomeado OpcPlc (em termos de geração de certificado, CN=OpcPlc) e o certificado do agente do Akri deve ser nomeado AkriBroker (CN=AkriBroker) (não há requisitos para o nome da AC).

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

Se você optar por usar o Gerador de Certificados do OPC Foundation, siga estas etapas para compilar:

Instale o Perl.
Baixe o arquivo .zip ou clone o repositório gerador de certificados do OPC Foundation (Misc-Tools).
Execute build_certificate-generator.bat no prompt de comando do desenvolvedor do Visual Studio (o Visual Studio 2022 é recomendado).
Criar Opc.Ua.CertificateGenerator solução do Visual Studio 2022.
Verifique se Opc.Ua.CertificateGenerator.exe foi criado com êxito no build/Debug/Opc.Ua.CertificateGenerator diretório.

Use os comandos de exemplo a seguir para criar certificados. Consulte Misc-Tools para obter mais opções:

ac Self-Signed:

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

Certificado do 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 do agente 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 arquivo para AC usando OpenSSL (somente se você criou a AC a partir do gerador, o que não teria o .crl arquivo).

Se você optar por usar o OpenSSL, aqui está uma lista de referências:

Criar um segredo do Kubernetes opcua-broker-credentials

O certificado do cliente OPC UA é passado para o agente de monitoramento do 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 arquivo para que eles apontem para as credenciais criadas na seçã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 em mountPath /etc/opcua-certs/client-pki, conforme mostrado no modelo de helm de configuração do OPC UA. Esse caminho é onde os agentes esperam encontrar os certificados.

Montar a pasta de certificados na ACI

Siga estas instruções para criar um compartilhamento de arquivos do Azure.

Depois de criar o compartilhamento de arquivos e certificados do Azure, carregue os certificados de servidor ca e OPC UA para o compartilhamento de arquivos, conforme descrito.

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

Observação

Como adicionamos um sinalizador de segurança no modelo, isso faz com que um certificado arbitrário seja gerado no compartilhamento de arquivos. Você pode excluir todos os certificados não identificados no compartilhamento de arquivos (os caminhos de pasta devem ser exatamente iguais ao diagrama anterior).

Depois de seguir estas etapas de segurança, clique em Reiniciar em sua instância de contêiner para atualizá-la e executar com os certificados montados.

Executar o Akri e implantar o aplicativo Web

Siga a seção anterior para executar o Akri e descobrir seus servidores, mas agora adicione uma linha --set opcua.configuration.mountCertificates='true' ao final do comando. opcua.configuration.discoveryDetails.discoveryUrls Substitua pelas URLs encontradas 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, você pode seguir a seção sobre como implantar um aplicativo Web de detecção de anomalias como um consumidor final dos agentes para ver os valores do OPC PLC em sua página da Web.

Limpar

Exclua o aplicativo de detecçã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
```
Exclua a implantação do servidor OPC UA navegando até a instância do contêiner e selecione Excluir no portal do Azure.

Próximas etapas

Visão geral do AKS Edge Essentials

Compartilhar via