No ano passado, projetamos (e continuamos a apoiar) vários projetos de IIoT. Você já deve ter ouvido falar sobre a IIoT, mas, no caso, tentaremos explicar da maneira mais simples possível o que é e por que é interessante para desenvolvedores, arquitetos e administradores de soluções altamente carregadas.
A IoT - a Internet das coisas - envolve o controle de dispositivos projetados para executar tarefas domésticas simples (abra a porta da garagem quando o carro parar, acenda a luz usando um sensor ou comando de movimento, monitore a temperatura ambiente) e, em seguida, sob a IIoT - a Internet industrial das coisas - geralmente há tendo em vista a “digitalização” dos dados das indústrias, com base nas quais análises especializadas podem ser realizadas, geralmente com a ajuda do aprendizado de máquina.
Por exemplo, você pode coletar e analisar dados de motores rotativos para aprender sobre falhas no tempo e economizar em reparos. Substituir uma turbina completamente quebrada é muito mais caro do que um reparo oportuno. Outro exemplo é a mineração de carvão. A análise de dados sobre a composição do ar nas minas permite que você responda a tempo de exceder os valores permitidos. Isso ajuda a evitar situações de risco de vida para os mineiros.
O fluxo de dados - dos sensores nos campos, das máquinas industriais, dos sensores de gás - vai para os agregados de hubs e, além disso, para a plataforma de processamento e análise de dados.
Queremos falar sobre a aparência de uma arquitetura, como coletar e analisar dados de maneira bastante simples, e nos concentrarmos nas especificidades de aplicativos individuais. Contaremos com traduções de artigos em inglês e nossa própria experiência em design. Este artigo está traduzido com nossas explicações e adições.
No primeiro artigo, tentaremos criar uma arquitetura IIoT, na qual transmitiremos ainda mais os dados dos sensores e depois os transferiremos para um sistema que fornece processamento, análise, aprendizado de máquina e monitoramento dos dados recebidos.
Arquitetura criada
Freqüentemente, na IoT industrial, não há acesso direto aos sensores e sistemas de controle; portanto, um gateway é usado para conectar os níveis OT (tecnologia operacional) e TI (tecnologia da informação).
Assim, a arquitetura IIoT geralmente inclui: dispositivos finais, gateways, hubs regionais e, finalmente, sistemas de processamento e armazenamento de informações.
A arquitetura criada deve oferecer uma oportunidade:
- Colete dados dos sensores para o gateway
- Transferir dados para a nuvem ou data center
- Atualizar automaticamente configurações de gateway
- Manter transferência e processamento seguros de dados
Na imagem: arquitetura do sistema e software criados que usaremos para construí-lo em cada nível.
Os sensores coletam dados e os enviam para o gateway usando uma variedade de protocolos com e sem fio (Serial, RS-485, MODBUS, barramento CAN, OPC UA, BLE, WiFi, etc.). Em nosso exemplo, teremos em mente que os dados chegam ao gateway via Wi-Fi.
Como gateway, usaremos o Raspberry Pi, no qual o intermediário Mosquitto e o agente MiNiFi serão lançados. Mosquitto é um broker de mensagens leve e de código aberto que usaremos para transmitir dados a partir de sensores usando o protocolo MQTT. O MQTT adiciona uma sobrecarga mínima e, portanto, é conveniente para uso na IoT quando os recursos de hardware dos dispositivos finais são limitados (por exemplo, telefones e microcontroladores são usados).
Apache MiNiFi - um subprojeto Apache NiFi - um agente leve que implementa a funcionalidade principal do Apache NiFi, projetado especificamente para coletar dados em dispositivos finais.
O MiNiFi é compacto, utiliza minimamente os recursos e permite o gerenciamento centralizado de todos os agentes. Ele se conecta facilmente ao NiFi usando o Site-to-Site (S2S), o que permite criar um controle completo do fluxo de dados - escalável, seguro e com uma ideia clara de todos os estágios da transferência de informações.
Em nosso sistema, o MiNiFi se inscreverá em todos os tópicos do broker Mosquitto e encaminhará cada mensagem ao NiFi definido no nível regional. Você também pode usá-lo para conectar-se a um sistema SCADA ou qualquer outra fonte de dados OT.
No nível regional, existem dois componentes:
O Apache NiFi é um poderoso sistema de gerenciamento de fluxo de dados que suporta mais de 200 conectores. Uma interface gráfica permite projetar rápida e facilmente fluxos de dados.
O NiFi não sacrifica o poder pela simplicidade. É um sistema distribuído bem escalável, com entrega garantida, contrapressão (a capacidade de armazenar dados antes de enviá-los para outros sistemas mais lentos) e balanceamento de carga. Essa funcionalidade faz do NiFi uma excelente ferramenta para aplicativos de IoT que geralmente funcionam em ambientes de rede instáveis.
Em nosso sistema, o NiFi é um centro de coleta de dados que os redireciona para vários sistemas e aplicativos (HDFS, HBase, Kafka, S3 etc.).
O MiNiFi C2 Server (Comando e Controle do MiNiFi) é outro subprojeto do Apache NiFi que ainda está em desenvolvimento. Seu papel é ser o ponto central da configuração de centenas e milhares de agentes de MiNiFi que estão em produção no campo (várias salas, fábricas, territórios). O servidor C2 gerencia as configurações de fluxo MiNiFi (na terminologia C2 - classe de aplicativos com versão) e as publica por meio da API Rest. Os agentes MiNiFi podem se conectar a essa API em uma determinada frequência para atualizar sua própria configuração.
Então, vamos começar a criar nosso protótipo.
Contrato de Nome de Domínio
Para configurações adicionais dos vários sistemas que devem entrar em contato, vamos concordar com os nomes de domínio que usaremos nas configurações.
Preparação para Raspberry Pi: MQTT e MiNiFi
Para instalar o broker MQTT Mosquitto e o agente MiNiFi, execute os seguintes comandos no seu Raspberry Pi.
Por padrão, o MiNiFi contém um conjunto mínimo de manipuladores de dados. É possível adicionar manipuladores adicionais do kit NiFI adicionando um arquivo NAR (arquivo NiFi) ao diretório da biblioteca.
Com o último comando, adicionamos o manipulador NAR MQTT.
sudo apt-get update
Agora vamos instalar o servidor de gerenciamento de configuração MiNiFi C2 no servidor que estará disponível com o Raspberry Pi
Instalação e configuração do servidor MiNiFi C2.
Instale o servidor MiNiFi C2 em um servidor público que estará disponível com os agentes do MiNiFi. Você pode usar a distribuição hierárquica de servidores C2 para infraestruturas de rede complexas, conforme descrito abaixo. Execute o seguinte comando para instalar o servidor C2:
wget http://apache.crihan.fr/dist/nifi/minifi/0.4.0/minifi-c2-0.4.0-bin.tar.gz tar -xvf minifi-c2-0.4.0-bin.tar.gz cd minifi-c2-0.4.0
- O servidor C2 publicará a configuração organizada da classe. O C2 suporta "provedores de configuração" conectáveis:
- O CacheConfigurationProvider, que atualiza a configuração com base na configuração especificada no sistema de arquivos ou no S3
- O DelegatingConfigurationProvider, que passa a delegação para outro servidor C2 para criar estruturas hierárquicas de servidores C2.
- O NiFiRestConfigurationProvider, que remove modelos dos servidores Apache NiFi por meio de sua API REST.
Vamos configurar o servidor C2 para usar o NiFi como um provedor de configuração. Edite o arquivo ./conf/minifi-c2-context.xml, descomente o bloco xml
<bean class="org.apache.nifi.minifi.c2.provider.nifi.rest.NiFiRestConfigurationProvider">
e anote o endereço do servidor NiFi ( http: //nifi.iot.local: 8080 )
<constructor-arg> <value>http://nifi.iot.local:8080/nifi-api</value> </constructor-arg>
Outras configurações do MiNiFi no Raspberry Pi
Por padrão, para adicionar manipuladores e suas configurações, você precisa editar a configuração ./conf/config.yml. A configuração também pode ser escrita manualmente ou criada usando a GUI do Apache NiFi, seguida pela exportação da configuração como um modelo. Um modelo é um arquivo XML que deve ser convertido em um arquivo de configuração YML do MiMLiFi usando o kit de ferramentas do MiNiFi. Aqui está um exemplo de arquivo de configuração que monitora o arquivo no dispositivo e encaminha cada nova linha para o NiFi usando o protocolo S2S.
Para o nosso projeto, não usaremos o ajuste manual. De fato, se houver muitos agentes MiNiFi, não será fácil parar manualmente, editar o config.yml e reiniciar o agente sempre que a configuração for alterada.
O MiNiFi usa o Change Ingestor, com o qual o agente aprende sobre as novas configurações possíveis. O Change Ingestor é um plug-in e há três ChangeIngestor que são suportados originalmente pelo MiNiFi.
- FileChangeIngestor
- RestChangeIngestor
- PullHttpChangeIngestor
Usaremos o PullHttpChangeIngestor para acessar periodicamente o servidor C2 e baixar a nova configuração. Para configurar este Ingestor, você precisa editar o arquivo ./conf/bootstrap.conf, descomente as linhas correspondentes e defina as seguintes configurações:
nifi.minifi.notifier.ingestors=org.apache.nifi.minifi.bootstrap.configuration.ingestors.PullHttpChangeIngestor
Com essa configuração, cada agente MiNiFi acessará o servidor C2 usando o protocolo API REST em http: //minifi-c2.iot.local: 10080 / c2 / config a cada minuto e solicitará uma nova configuração para a classe iot-minifi-raspberry-agent
Um ponto importante: a frequência de 1 minuto é configurada apenas para demonstração. Em um ambiente de produção, você provavelmente não precisará atualizar agentes com essa frequência.
Antes de iniciar o agente, vamos para o nível de controle e configure o servidor MiNiFi C2 e o próprio Apache NiFi.
Instalando e configurando um servidor NiFi
Instale o servidor NiFi acessível no servidor C2 e inicie-o.
wget http://apache.crihan.fr/dist/nifi/1.6.0/nifi-1.6.0-bin.tar.gz tar -xvf nifi-1.6.0-bin.tar.gz cd nifi-1.6.0 ./bin/nifi.sh start
Conecte-se à interface NiFi em http: // nifi-dev: 8080 / nifi / e crie um fluxo que será executado nos agentes MiNiFi, mas antes disso adicione a Porta de entrada (adicionada pressionando o botão Porta de entrada no menu) na camada raiz e nomeie-a de Raspberry MiNiFi. É aqui que o NiFi receberá arquivos de fluxo do MiNiFi.
Adicione Funil e conecte a Porta de Entrada ao Funil - em artigos futuros, abordaremos o processamento de dados no lado Apache NiFi.
Inclua um consumeMQTT do processador para assinar o broker do Mosquitto e inscreva-o em todos os tópicos iot / sensores / * observe que tcp: // raspberrypi: 1883 é equivalente a tcp: // localhost: 1883, pois esse encadeamento será executado no Raspberry Pi
Use o Processor UpdateAttribute para adicionar o atributo "version", que usaremos para notificar o sistema sobre a reconfiguração. Você pode adicionar atributos adicionais: registro de data e hora, local, nome do agente etc.
Por fim, adicione o Remote Process Group (RPG) - para enviar eventos recebidos ao NiFi. Combine todos os três desses processos.
Seu stream agora deve aparecer na captura de tela abaixo. O fluxo esquerdo será iniciado no próprio Apache NiFi e receberá dados do Apache MiNiFi. O encadeamento do lado direito não será iniciado no Apache Nifi, criado para fins de configuração e prototipagem, e será executado no Raspberry Pi.
Salve o fluxo correto como um modelo chamado "iot-minifi-raspberry-agent.v1". O princípio de nomeação é extremamente importante aqui. Devemos usar o mesmo nome que o nome da classe usado na configuração do MiNiFi.
É muito importante - você precisa destacar não apenas os componentes armazenados, mas também os relacionamentos entre eles.
Colocação e lançamento do aplicativo
Antes de iniciar os agentes MiNiFi no Raspberry Pi, vamos verificar se o servidor C2 está configurado corretamente. Abra o URL no seu navegador: http: // c2-server: 10080 / c2 / config? Class = iot-minifi-raspberry-agent & version = 1 O servidor C2 deve responder com um arquivo que contém a configuração do modelo que criamos no formato YML.
Se, em vez da configuração, o servidor lançar Java Exception, você encontrará um problema no servidor C2 mencionado aqui:
https://github.com/apache/nifi-minifi/pull/126#issuecomment-388856304
Você precisará instalar a versão 0.3.0 ou remover o arquivo javax.ws.rs-api-2.1.jar da pasta lib do diretório do servidor C2.
Se você observar os logs do servidor C2, poderá ver que o servidor aceitou a solicitação com os parâmetros {class = [agente-minifi-raspberry-iot], versão = [1]}
Agora que a conexão entre os componentes da arquitetura individual (MQTT, MiNiFi, NiFi e C2) foi estabelecida, inicie o agente MiNiFi no Raspberry Pi usando o comando:
./bin/minifi.sh start
Após alguns segundos, você deverá ver os logs do servidor C2. O host 192.168.1.50 (no nosso caso, o endereço IP do dispositivo Raspberry Pi) solicitou ao servidor C2 que fornecesse a versão mais recente da classe “iot-minifi-raspberry-agent”. Em comparação com a nossa solicitação anterior, que fizemos no navegador, você pode observar que o MiNiFi não indicou a versão. Se você abrir a configuração do agente MiNiFi em ./conf/config.yml, verá a mesma configuração que recebemos no navegador, definindo a solicitação manualmente.
O MQTT mostra que o agente MiNiFi se conectou ao broker e se inscreveu nos tópicos iot / sensores / #
Controle de transmissão
Ótimo, agora vamos fazer com que nossos sensores comecem a gerar dados e publicá-los no MQTT. O MiNiFi começará a enviar informações e enviar para o NiFi, conforme mostrado na captura de tela abaixo.
Importante: Para que o componente Apache NiFi comece a funcionar, você deve clicar no botão Reproduzir.
Agora, vamos dar uma olhada em uma dessas postagens dentro do NiFi. As informações são provenientes do sensor “iot / sensores / LightIntensity / z”, versão do aplicativo - 1
Atualização da configuração do MiNiFi
Agora que nossa infraestrutura está funcionando e os dados estão indo para o nosso "centro de dados", vamos instalar uma nova configuração MiNiFi. Vá para a interface Apache NiFi e edite o manipulador updateAttribute. Altere o atributo "version" para 2 em vez de 1 e salve o novo modelo "iot-minifi-raspberry-agent.v2". Isso é tudo. A nova configuração será implantada automaticamente.
Você pode ver os logs do servidor C2 e ver que uma nova versão do V2 foi detectada, o servidor não o encontrou no cache e o carregou.
Então o MiNiFi descobre a nova configuração, reserva a configuração anterior, descarrega a nova e reinicia:
No próximo artigo, falaremos sobre como montamos os sensores e os incorporamos à nossa arquitetura. Depois disso, falaremos sobre análise de dados.