Durante el año pasado, hemos diseñado (y seguimos apoyando) varios proyectos IIoT. Es posible que haya escuchado sobre IIoT, pero por si acaso, trataremos de explicar lo más simple posible qué es y por qué es interesante para los desarrolladores, arquitectos y administradores de soluciones altamente cargadas.
IoT, el Internet de las cosas, implica controlar dispositivos diseñados para realizar tareas domésticas simples (abrir la puerta del garaje cuando el automóvil se detiene, encender la luz con un sensor de movimiento o comando, controlar la temperatura ambiente), luego, bajo IIoT, el Internet industrial de las cosas, generalmente hay en vista de la "digitalización" de los datos de las industrias, sobre la base de los cuales se puede realizar un análisis experto, a menudo con la ayuda del aprendizaje automático.
Por ejemplo, puede recopilar y analizar datos de motores rotativos para conocer las fallas a tiempo y ahorrar en reparaciones. Reemplazar una turbina completamente rota es mucho más costoso que una reparación oportuna. Otro ejemplo es la minería del carbón. El análisis de los datos sobre la composición del aire en las minas le permite responder a tiempo a valores superiores a los permisibles. Esto ayuda a prevenir situaciones que amenazan la vida de los mineros.
El flujo de datos, desde sensores de campo, desde máquinas industriales, desde sensores de gas, va a centros de agregación y, además, a la plataforma de procesamiento y análisis de datos.
Queremos hablar sobre cómo se ve una arquitectura de este tipo, cómo recopilar y analizar datos de manera simple, y hacer hincapié en los detalles de las aplicaciones individuales. Nos basaremos en traducciones de artículos en inglés y en nuestra propia experiencia de diseño. Este artículo está traducido , con nuestras explicaciones y adiciones.
En el primer artículo, intentaremos crear una arquitectura IIoT, en la que transmitiremos más datos desde los sensores y luego los transferiremos a un sistema que proporciona procesamiento, análisis, aprendizaje automático y monitoreo de datos entrantes.
Arquitectura creada
A menudo, en IoT industrial no hay acceso directo a sensores y sistemas de control, por lo tanto, se utiliza una puerta de enlace para conectar los niveles OT (tecnología de operación) y TI (tecnología de la información).
Por lo tanto, la arquitectura IIoT generalmente incluye: dispositivos finales, puertas de enlace, centros regionales y, finalmente, sistemas de procesamiento y almacenamiento de información.
La arquitectura creada debería brindar una oportunidad:
- Recopilar datos de sensores a la puerta de enlace
- Transfiera datos a la nube o al centro de datos
- Actualizar automáticamente las configuraciones de puerta de enlace
- Mantener una transferencia y procesamiento de datos seguros
En la imagen: arquitectura del sistema y software creados que usaremos para construirlo en cada nivel.
Los sensores recopilan datos y los envían a la puerta de enlace utilizando una variedad de protocolos cableados e inalámbricos (serie, RS-485, MODBUS, bus CAN, OPC UA, BLE, WiFi, etc.). En nuestro ejemplo, tendremos en cuenta que los datos llegan a la puerta de enlace a través de WiFi.
Como puerta de entrada, utilizaremos la Raspberry Pi, en la cual se lanzará el agente Mosquitto y el agente MiNiFi. Mosquitto es un agente de mensajes de código abierto y liviano que usaremos para transmitir más datos desde los sensores utilizando el protocolo MQTT. MQTT agrega una sobrecarga mínima y, por lo tanto, es conveniente para su uso en IoT cuando los recursos de hardware de los dispositivos finales son limitados (por ejemplo, se usan teléfonos y microcontroladores).
Apache MiNiFi , un subproyecto Apache NiFi , un agente liviano que implementa la funcionalidad principal de Apache NiFi, específicamente diseñado para recopilar datos en dispositivos finales.
MiNiFi es compacto, utiliza recursos mínimamente y permite la gestión centralizada de todos los agentes. Se conecta fácilmente a NiFi utilizando Site-to-Site (S2S), que le permite construir un control de flujo de datos completo, escalable, seguro y dando una idea clara de todas las etapas de la transferencia de información.
En nuestro sistema, MiNiFi se suscribirá a todos los temas del agente de Mosquitto y reenviará cada mensaje al conjunto de NiFi a nivel regional. También puede usarlo para conectarse a un sistema SCADA o cualquier otra fuente de datos OT.
A nivel regional, hay dos componentes:
Apache NiFi es un potente sistema de gestión de flujo de datos que admite más de 200 conectores. Una interfaz gráfica le permite diseñar de manera rápida y fácil flujos de datos.
NiFi no sacrifica el poder por la simplicidad. Es un sistema distribuido bien escalable con entrega garantizada, contrapresión (la capacidad de almacenar datos antes de cargarlos en otros sistemas más lentos) y equilibrio de carga. Esta funcionalidad convierte a NiFi en una excelente herramienta para aplicaciones de IoT que a menudo funcionan en entornos de red inestables.
En nuestro sistema, NiFi es un centro de recopilación de datos que los redirige a varios sistemas y aplicaciones (HDFS, HBase, Kafka, S3, etc.).
MiNiFi C2 Server (MiNiFi Command & Control) es otro subproyecto de Apache NiFi que aún está en desarrollo. Su papel es ser el punto central de la configuración de cientos y miles de agentes MiNiFi que están en producción en el campo (varios pasillos, fábricas, territorios). El servidor C2 gestiona las configuraciones de transmisión MiNiFi (en terminología C2 - clase de aplicaciones versionadas) y las publica a través de la API Rest. Los agentes de MiNiFi pueden conectarse a esta API a una frecuencia determinada para actualizar su propia configuración.
Entonces, comencemos a crear nuestro prototipo.
Acuerdo de nombre de dominio
Para una mayor configuración de los diversos sistemas que deben contactarse entre sí, acordémos los nombres de dominio que usaremos en las configuraciones.
Preparación de Raspberry Pi: MQTT y MiNiFi
Para instalar el agente MQTT Mosquitto y el agente MiNiFi, ejecute los siguientes comandos en su Raspberry Pi.
Por defecto, MiNiFi contiene un conjunto mínimo de manejadores de datos. Puede agregar controladores adicionales desde el kit NiFI agregando un archivo NAR (archivo NiFi) al directorio de la biblioteca.
Con el último comando, agregamos el controlador NAR MQTT.
sudo apt-get update
Ahora instalemos el servidor de administración de configuración MiNiFi C2 en el servidor que estará disponible con Raspberry Pi
Instalación y configuración del servidor MiNiFi C2.
Instale el servidor MiNiFi C2 en un servidor público que estará disponible con agentes MiNiFi. Puede usar la distribución jerárquica de servidores C2 para infraestructuras de red complejas, como se describe a continuación. Ejecute el siguiente comando para instalar el 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
- El servidor C2 publicará la configuración organizada de la clase. C2 admite "proveedores de configuración" conectables:
- CacheConfigurationProvider, que actualiza la configuración en función de la configuración especificada en el sistema de archivos o en S3
- DelegatingConfigurationProvider, que pasa la delegación a otro servidor C2 para crear estructuras jerárquicas de servidores C2.
- NiFiRestConfigurationProvider, que elimina plantillas de los servidores Apache NiFi a través de su API REST.
Configuraremos el servidor C2 para usar NiFi como proveedor de configuración. Edite el archivo ./conf/minifi-c2-context.xml, descomente el bloque xml
<bean class="org.apache.nifi.minifi.c2.provider.nifi.rest.NiFiRestConfigurationProvider">
y escriba la dirección del servidor NiFi ( http: //nifi.iot.local: 8080 )
<constructor-arg> <value>http://nifi.iot.local:8080/nifi-api</value> </constructor-arg>
Configuración adicional de MiNiFi en Raspberry Pi
De manera predeterminada, para agregar controladores y sus configuraciones, debe editar la configuración ./conf/config.yml. La configuración también se puede escribir manualmente o crear usando la GUI de Apache NiFi, seguido de exportar la configuración como una plantilla. Una plantilla es un archivo XML que debe convertirse en un archivo de configuración MiMLiFi YML utilizando el kit de herramientas MiNiFi. Aquí hay un archivo de configuración de ejemplo que monitorea el archivo en el dispositivo y reenvía cada nueva línea a NiFi usando el protocolo S2S.
Para nuestro proyecto, no utilizaremos la sintonización manual. De hecho, si hay muchos agentes MiNiFi, no será fácil detener manualmente, editar config.yml y reiniciar el agente cada vez que cambie la configuración.
MiNiFi utiliza Change Ingestor, con el cual el agente aprende sobre nuevas configuraciones posibles. Change Ingestor es un complemento, y hay tres ChangeIngestor que MiNiFi admite de forma nativa.
- FileChangeIngestor
- RestChangeIngestor
- PullHttpChangeIngestor
Utilizaremos PullHttpChangeIngestor para acceder periódicamente al servidor C2 y descargar la nueva configuración. Para configurar este Ingestor, debe editar el archivo ./conf/bootstrap.conf, descomentar las líneas correspondientes y establecer la siguiente configuración:
nifi.minifi.notifier.ingestors=org.apache.nifi.minifi.bootstrap.configuration.ingestors.PullHttpChangeIngestor
Con esta configuración, cada agente MiNiFi accederá al servidor C2 utilizando el protocolo API REST en http: //minifi-c2.iot.local: 10080 / c2 / config cada minuto y solicitará una nueva configuración para la clase iot-minifi-raspberry-agent
Un punto importante: la frecuencia de 1 minuto se establece solo para demostración. En un entorno de producción, lo más probable es que no tenga que actualizar los agentes con tanta frecuencia.
Antes de iniciar el agente, pasemos al nivel de control y configuremos el servidor MiNiFi C2 y el propio Apache NiFi.
Instalar y configurar un servidor NiFi
Instale el servidor NiFi accesible desde el servidor C2 e inícielo.
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
Conéctese a la interfaz NiFi en http: // nifi-dev: 8080 / nifi / y cree un flujo que se ejecutará en los agentes MiNiFi, pero antes de eso agregue el Puerto de entrada (agregado presionando el botón Puerto de entrada en el menú) en la capa raíz y asígnele un nombre. de Raspberry MiNiFi. Aquí es donde NiFi recibirá los archivos de transmisión de MiNiFi.
Agregue el embudo y conecte el puerto de entrada al embudo: en futuros artículos tocaremos el procesamiento de datos en el lado Apache NiFi.
Agregue un procesador consumeMQTT para suscribirse al agente Mosquitto y suscríbase a todos los temas iot / sensores / * tenga en cuenta que tcp: // raspberrypi: 1883 es equivalente a tcp: // localhost: 1883, ya que este hilo se ejecutará en Raspberry Pi
Use el procesador UpdateAttribute para agregar el atributo "versión", que usaremos para notificar al sistema sobre la reconfiguración. Puede agregar cualquier atributo adicional: marca de tiempo, ubicación, nombre del agente, etc.
Finalmente, agregue el Grupo de proceso remoto (RPG) para enviar los eventos recibidos a NiFi. Combina los tres procesos.
Su transmisión ahora debería verse como en la captura de pantalla a continuación. El flujo izquierdo se lanzará en Apache NiFi y recibirá datos de Apache MiNiFi. El hilo de la derecha no se iniciará dentro de Apache Nifi, creado con fines de creación de prototipos y configuración, y se ejecutará en la Raspberry Pi.
Guarde la secuencia correcta como una plantilla llamada "iot-minifi-raspberry-agent.v1". El principio de denominación es extremadamente importante aquí. Debemos usar el mismo nombre que el nombre de la clase utilizada en la configuración de MiNiFi.
Es muy importante: debe resaltar no solo los componentes almacenados, sino también las relaciones entre ellos.
Colocación y lanzamiento de la aplicación.
Antes de iniciar los agentes MiNiFi en la Raspberry Pi, verifiquemos que el servidor C2 esté configurado correctamente. Abra la URL en su navegador: http: // c2-server: 10080 / c2 / config? Class = iot-minifi-raspberry-agent & version = 1 C2 Server debe responder con un archivo que contenga la configuración de la plantilla que creamos en formato YML.
Si, en lugar de la configuración, el servidor arroja la Excepción Java, encuentra un problema en el servidor C2 mencionado aquí:
https://github.com/apache/nifi-minifi/pull/126#issuecomment-388856304
Deberá instalar la versión 0.3.0 o eliminar el archivo javax.ws.rs-api-2.1.jar de la carpeta lib del directorio del servidor C2.
Si observa los registros del servidor C2, puede ver que el servidor ha aceptado la solicitud con los parámetros {class = [iot-minifi-raspberry-agent], version = [1]}
Ahora que la conexión entre los componentes de la arquitectura individual (MQTT, MiNiFi, NiFi y C2) está establecida, inicie el agente MiNiFi en la Raspberry Pi con el comando:
./bin/minifi.sh start
Después de unos segundos, debería ver los registros del servidor C2. El host 192.168.1.50 (en nuestro caso, la dirección IP del dispositivo Raspberry Pi) solicitó al servidor C2 que proporcionara la última versión de la clase "iot-minifi-raspberry-agent". En comparación con nuestra solicitud anterior, que hicimos en el navegador, puede observar que MiNiFi no indicó la versión. Si abre la configuración del agente MiNiFi en ./conf/config.yml, verá la misma configuración que recibimos en el navegador, configurando la solicitud a mano.
MQTT muestra que el agente MiNiFi se conectó al corredor y se suscribió a los temas iot / sensores / #
Control de la transmisión
Genial, ahora hagamos que nuestros sensores comiencen a generar datos y publicarlos en MQTT. MiNiFi comenzará a cargar información y enviarla a NiFi, como se muestra en la captura de pantalla a continuación.
Importante: para que el componente Apache NiFi comience a funcionar, debe hacer clic en el botón Reproducir.
Ahora, echemos un vistazo a una de estas publicaciones dentro de NiFi. La información proviene del sensor “iot / sensores / LightIntensity / z”, versión de la aplicación - 1
Actualización de configuración de MiNiFi
Ahora que nuestra infraestructura está funcionando y los datos van a nuestro "centro de datos", instalemos una nueva configuración de MiNiFi. Vaya a la interfaz Apache NiFi y edite el controlador updateAttribute. Cambie el atributo "versión" a 2 en lugar de 1 y guarde la nueva plantilla "iot-minifi-raspberry-agent.v2". Eso es todo La nueva configuración se implementará automáticamente.
Puede mirar los registros del servidor C2 y ver que se detectó una nueva versión de V2, el servidor no la encontró en su caché y la cargó.
Luego, MiNiFi descubre la nueva configuración, reserva la configuración anterior, descarga la nueva y reinicia:
En el próximo artículo, hablaremos sobre cómo ensamblamos los sensores y los incorporamos a nuestra arquitectura. Después de eso, hablaremos sobre el análisis de datos.