Archivo de la etiqueta: Formación Node-RED

Biblioteca Node-RED

5 respuestas

Node-RED dispone de una biblioteca de nodos, flujos y colecciones que la comunidad alimenta, donde obtener muchos recursos para la programación de Node-RED.

Los nodos de Node-RED se empaquetan como módulos y se publican en el repositorio público de npm https://www.npmjs.com/. Una vez publicados en npm, se pueden agregar a la biblioteca de flujo mediante un formulario.

Node-RED Library: https://flows.nodered.org/

Para añadir un nodo a Node-RED: https://nodered.org/docs/getting-started/adding-nodes

  • Usando el editor en gestor de paleta: https://nodered.org/docs/user-guide/editor/palette/manager 
  • Instalar desde npm con el comando npm install <nombre-paquete>
  • Con el fichero package.json que se genera en los proyectos. npm agregará automáticamente módulos adicionales instalados a la sección de dependencias del archivo package.json en su directorio de usuario.

Para actualizar los nodos:

  • La forma más fácil de buscar actualizaciones de nodos es abrir el Administrador de paleta en el editor.
  • También puede buscar actualizaciones desde la línea de comandos usando npm. En su directorio de usuario, ~/.node-red ejecute el comando: npm outdated y luego para los paquetes actualizables usar npm install <name-of-module>@latest

Cualquiera que sea la opción que adopte, deberá reiniciar Node-RED para cargar las actualizaciones.

Más información sobre package.json: https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/ 

Si quieres crear tu propio nodo: https://nodered.org/docs/creating-nodes/first-node 

Core Nodes

La paleta Node-RED incluye un conjunto predeterminado de nodos que son los bloques de construcción básicos para crear flujos.

Todos los nodos incluyen documentación que puede ver en la pestaña de la barra lateral Información cuando selecciona un nodo.

Core nodes: https://nodered.org/docs/user-guide/nodes

Cuando instala Node-RED, se inicia con un conjunto predeterminado de nodos. Hay 8 categorías principales de nodos en la instalación predeterminada: entradas, salidas, funciones, social, almacenamiento, análisis, avanzado y Raspberry Pi (si se instala en una Raspberry Pi). 

Más información: http://noderedguide.com/node-red-lecture-4-a-tour-of-the-core-nodes/ 

Nodos Más Usados

A 2/12/2020 hay 2924 nodos.

A 23/06/22 hay 3923 nodos.

Los nodos más descargados: https://flows.nodered.org/search?type=node&sort=downloads 

A 2/12/2020 hay 1731 flows.

A 23/06/22 hay 2202 flows.

Los más descargados: https://flows.nodered.org/search?type=flow&sort=downloads 

A 2/12/2020 hay 297 colecciones.

A 23/06/22 hay 672 colecciones.

Los más descargados: https://flows.nodered.org/search?type=collection&sort=downloads 

Usuarios Node-RED

Usuarios interesantes a los que seguir en https://flows.nodered.org/ 

Colecciones en Librería Node-RED

En la librería de Node-RED disponemos de colecciones, que son agrupaciones de nodos y flujos para agrupar y tener guardados.

Ejemplo de colección: https://flows.nodered.org/collection/cQjGjy9o32Rj

Colecciones interesantes:

Flujos en Librería Node-RED

En la librería de Node-RED disponemos de Flows creados por los usuarios y que comparten en https://flows.nodered.org/search?type=flow

Algunos Flujos destacados:

Monitorizar Raspberry Pi

Este flujo muestra en un dashboard la CPU, Memoria, uso del disco y temperatura del CPU de la Raspberry Pi donde está Node-RED. También hay dos botones para reiniciar y apagar el sistema. Es necesario instalar el nodo de Dashboard.

Flujo: https://flows.nodered.org/flow/fa6e4749ff7f9067fd6b5330bc54f9e3

Timer in Dashboard

Buen ejemplo de un timer en Dashboard: https://flows.nodered.org/flow/f24cb20846f57eec19ed617b25cb61ae

Este temporizador en NodeRED se puede implementar como un único subflujo configurable a través de variables de entorno. Para configurar el subflujo, debe proporcionar la iteración del temporizador (cada temporizador debe tener su propio número como: 1 | 2 |… n) y valores para la payload en el inicio y la parada (cadena).

Más información:

Nodos necesarios:

Schneider POWERLOGIC PM5150 via MODBUS TCP

Flow: https://flows.nodered.org/flow/7c058a46b095af5b8bd469c7c5328454

Subflow para leer variables del power meter PM5150 de Schneider.

Usa el nodo https://flows.nodered.org/node/node-red-contrib-modbus contra Schneider Power Logic PM5000 series: https://www.se.com/ww/en/product-range/61281-powerlogic-pm5000-series/

Se hace una función para leer y sacar un objeto json con los datos que devuelve el nodo de Modbus.

Nodos Adicionales

Hay más de 3000 nodos, algunos de los más interesantes son:

Extra Nodes: https://github.com/node-red/node-red-nodes 

Más información sobre nodos interesantes:

Nodos en Node-RED por Categorías

Básicos

Nodo Generador de Datos

Un nodo Node-RED para crear una cadena de valores de datos ficticios a partir de una plantilla. Útil para casos de prueba.

Nodo: https://flows.nodered.org/node/node-red-node-data-generator 

Node RBE

Un nodo Node-RED que proporciona informes por excepción (RBE) y capacidad de banda muerta. RBE = Report by Exception

El nodo se bloquea a menos que el valor entrante cambie – modo RBE, o cambie en más de una cierta cantidad (valor absoluto o porcentaje) – modos de banda prohibida.

Básicamente este nodo hace de filtro, de detector de flanco y puede servir para implementar histéresis.

Nodo: https://flows.nodered.org/node/node-red-node-rbe

Explicar: https://cookbook.nodered.org/basic/report-by-exception 

Nodo Exec

El nodo exec le permite tomar cualquier comando del sistema existente, programa de Python o script que haya escrito y ejecutarlo desde node-red e incorporar los resultados en su flujo. Ejecuta un comando de sistema y devuelve su salida. 

El nodo puede ser configurado para esperar hasta que el comando se complete, o para enviar su salida a medida que el comando la genera.

Para más información leer la información del nodo en Node-RED

El comando que se ejecuta puede ser configurado en el nodo o proporcionado por el mensaje recibido.

Más información: http://www.steves-internet-guide.com/using-the-exec-node/ 

Una mejora: https://flows.nodered.org/node/node-red-node-daemon. Similar al nodo exec pero este llama al comando en el momento de inicio y luego conduce cualquier entrada al nodo al STDIN del comando en ejecución, y alimenta cualquier STDOUT a la primera salida. Útil para monitorear procesos basados en la línea de comandos.

Otra alternativa: https://flows.nodered.org/node/node-red-contrib-bigexec

Ejecutar un Script de Python

Ejecutar un script de Python usando el nodo exec.

Leer: https://www.rodened.com/posts/how-to-use-python-in-node-red-1/

También se le pueden pasar argumentos y el script de python debe estar preparado para recogerlos en el formato.

Existe un nodo que ayuda a hacerlo: https://flows.nodered.org/node/node-red-contrib-pythonshell

Instalar python y crear entornos virtuales desde Node-RED: https://flows.nodered.org/flow/778859ca2503db35ff0e12341508efef/in/vL27qorhYRSn

Flujo para ejecutar python con nodo exec y template: https://flows.nodered.org/flow/0a6e073bcd6bda364fafd32699837cc7

También se pueden escribir funciones en python usando estos nodos:

Ejemplo:

[{"id":"8a505abb.d39b08","type":"tab","label":"pythontest","disabled":false,"info":""},{"id":"f4c14ccb.34202","type":"inject","z":"8a505abb.d39b08","name":"","topic":"","payload":"","payloadType":"date","repeat":"","crontab":"","once":false,"onceDelay":0.1,"x":140,"y":240,"wires":[["e7344e2.b6687b"]]},{"id":"e7344e2.b6687b","type":"template","z":"8a505abb.d39b08","name":"","field":"payload","fieldType":"msg","format":"python","syntax":"plain","template":"import time\n\nwhile True:\n    print(time.ctime())\n    time.sleep(10)\n","output":"str","x":320,"y":240,"wires":[["ab959ca2.a43e"]]},{"id":"ab959ca2.a43e","type":"file","z":"8a505abb.d39b08","name":"","filename":"pythontest.py","appendNewline":false,"createDir":false,"overwriteFile":"true","encoding":"none","x":510,"y":240,"wires":[["7cbbdbb3.3de674"]]},{"id":"7cbbdbb3.3de674","type":"exec","z":"8a505abb.d39b08","command":"python3 pythontest.py","addpay":false,"append":"","useSpawn":"true","timer":"","oldrc":false,"name":"","x":740,"y":240,"wires":[["44900928.37bb68"],[],[]]},{"id":"44900928.37bb68","type":"debug","z":"8a505abb.d39b08","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":970,"y":240,"wires":[]}]

HTTP Request

Hacer peticiones de HTTP desde Node-RED. Estos nodos están instalados por defecto.

HTTP requests

Nodo JSON

JSON, es una forma estándar de representar un objeto JavaScript como una cadena. Las API web suelen utilizarlo para devolver datos.

Si una propiedad de mensaje contiene una cadena JSON, primero se debe analizar en su objeto JavaScript equivalente antes de poder acceder a las propiedades que contiene. Node-RED proporciona un nodo JSON para realizar esta conversión.

Conversión desde/hacia JSON: https://cookbook.nodered.org/basic/convert-json 

Más información: http://www.steves-internet-guide.com/working-with-json-data-node-red/ 

Nodo File

Nodo file, lee y escribe ficheros locales en el host donde está instalada la instancia de Node-RED.

El nombre del archivo debe ser una ruta absoluta, de lo contrario será relativo al directorio de trabajo del proceso Node-RED, que normalmente es .node-red

Uso de nodo file storage en docker.

  • ruta de fichero en docker es /data
  • ruta por defecto /usr/src/node-red/

Nodo Lógica Booleana

Un conjunto de nodos lógica booleana mejorado para Node-RED: flow interruption node, blinker node, invert node, filter node, etc… con valores persistentes después del reinicio y más.

Nodos: https://flows.nodered.org/node/node-red-contrib-boolean-logic-ultimate 

Nodo Moment

Nodo interesante para manejo de fechas:

Con este nodo solucionas el problema de la fecha, que coge la fecha del contenedor o servidor si no está bien configurada.

Nodo Buffer Parser

Nodos de Node-RED para convertir valores hacia y desde búfer/matriz. Admite Big/Little Endian, BCD, intercambio de bytes y mucho más

Muy interesante para tratamiento de datos

Nodo: https://flows.nodered.org/node/node-red-contrib-buffer-parser 

Timers y Loops

Timer Switch 

Un temporizador de Node-RED fácil, intuitivo y preciso que le permite encender/apagar algo varias veces al día y admite horarios de tan solo 1 segundo.

Timer switch https://flows.nodered.org/node/node-red-contrib-timerswitch muy interesante para temporizaciones.

Uso con dashboard: https://www.instructables.com/id/Day-Timer-Using-Node-Red-With-Persistant-Memory/ 

Loop

Nodos Node-RED para ayudar al flujo de bucles.

Este módulo tiene 3 nodos:

Counter loop: https://flows.nodered.org/node/node-red-contrib-loop-processing 

Nodo Interval Length

Un nodo Node Red para medir la longitud del intervalo entre mensajes sucesivos

Nodo: https://flows.nodered.org/node/node-red-contrib-interval-length

Nodo BigTimer

BigTimer es un nodo de temporización Node-Red que ofrece una gama de funciones de temporización. Los BigTimers se pueden utilizar individualmente o en grupos. Soporte completo para crepúsculo/atardecer y variaciones también control día/semana/mes (y días especiales). El nodo ofrece salidas adecuadas para MQTT, voz y bases de datos. 

Nodo: https://flows.nodered.org/node/node-red-contrib-bigtimer

Más información: https://tech.scargill.net/big-timer/

Nodo Cron/Temporizar eventos

Un nodo programador flexible (cron, eventos solares, fechas simples) para Node-RED con control dinámico total y soporte de zona horaria

Nodo: https://flows.nodered.org/node/node-red-contrib-cron-plus

Más Básico: https://flows.nodered.org/node/node-red-contrib-cron

Flujo de cron programable desde Dashboard: https://flows.nodered.org/flow/79a66966a6cc655a827872a4af794b94

Nodo Chronos

Programación, manejo de colas, enrutamiento, filtrado y manipulación de nodos basados en el tiempo Node-RED.

Nodo: https://flows.nodered.org/node/node-red-contrib-chronos 

Nodo iCalc

Este módulo Node RED obtiene los eventos de una URL ical o de un servidor caldav.

Nodo: https://flows.nodered.org/node/node-red-contrib-ical-events 

Nodo ActionFlows

Crea patrones de diseño extensibles, en bucle y reutilizables para flujos. 

ActionFlows trae bucles fáciles de usar y características OOP (programación orientada a objetos) al paradigma de programación de flujo de Node-RED. Tres nodos le permiten crear flujos extensibles, con alcance, en bucle y priorizados. Las utilidades incluyen evaluaciones comparativas de rendimiento con precisión de nanosegundos. 

Para comprender ActionFlows, revise cada sección comenzando con Conceptos básicos a continuación y los ejemplos de cada sección.

Nodo: https://flows.nodered.org/node/node-red-contrib-actionflows 

Stop Timer

Envía el mensaje a través de la primera salida después de la duración del temporizador. Un nuevo mensaje recibido antes de que expire el temporizador reemplazará el mensaje existente y el temporizador se reiniciará, a menos que el nuevo mensaje tenga un payload de ‘stop’ o ‘STOP’, que detendrá el temporizador.

Nodo: https://flows.nodered.org/node/node-red-contrib-stoptimer-varidelay

Utilidades

Nodo Toggle

Toggle switch node para Node-red. Nodopara cualquier conmutador (físico o virtual), almacenando su estado y proporcionando operación de alternancia sin necesidad de utilizar nodos de función o variables de flujo / globales.

Nodo: https://flows.nodered.org/node/node-red-contrib-toggle

Nodo Enrutado de Mensajes

Un nodo Node Red para enrutar mensajes entre nodos.

Nodo: https://flows.nodered.org/node/node-red-contrib-msg-router 

Nodo Summariser

Nodo para hacer cálculos de arrays como suma, contar, etc…

Nodo: https://flows.nodered.org/node/node-red-contrib-summariser

Nodo Máquina de Estados

Nodo: https://flows.nodered.org/node/node-red-contrib-xstate-machine

Nodo para Manipular Nodos

Nodos Node-Red para manipular flujos usando la API nodejs

Nodo: https://flows.nodered.org/node/node-red-contrib-flowman  

Nodo VNC

Nodo para conectar a un servidor y mandar eventos de teclado, ratón, etc…

Nodo: https://flows.nodered.org/node/node-red-contrib-vnc

Comunicaciones

Nodo socketio

Socket.IO es una biblioteca de JavaScript para aplicaciones web en tiempo real. Permite la comunicación bidireccional en tiempo real entre servidores y clientes web. Tiene dos partes: una biblioteca del lado del cliente que se ejecuta en el navegador y una biblioteca del lado del servidor para Node.js. Ambos componentes tienen una API casi idéntica. Como Node.js, está impulsado por eventos.

Nodo: https://flows.nodered.org/node/node-red-contrib-socketio 

Otros:

Nodo Utilidades Browser

Nodos Node-RED para la funcionalidad del navegador, como carga de archivos, cámara y micrófono. Muy interesante para subir datos, tomar datos de la cámara y del micrófono.

Nodo: https://flows.nodered.org/node/node-red-contrib-browser-utils 

Cliente Telnet

Un nodo Node-red para gestionar un diálogo con un servidor telnet sobre IP. Está destinado a simplificar el envío de consultas a un servidor y tratar las respuestas de forma asincrónica

Nodo: https://flows.nodered.org/node/node-red-contrib-telnet-client 

RedLink

Redlink es una forma de conectar muchas instancias de Node-Red juntas usando conexiones de «servicio» soft para crear esencialmente un cluster de «servicio» usando hardware dispar para crear una gran red de Node-Red.

Redlink no utiliza un sistema de mensajería tradicional, en realidad crea una malla jerárquica de servicios web interconectados utilizando HTTPS-POST como transporte y un concepto de enrutamiento similar a OSPF.

Nodo: https://flows.nodered.org/node/node-red-contrib-redlink

LDAP Login

Nodo Node-RED para Microsoft Active Directory (LDAP).

Nodo: https://flows.nodered.org/node/node-red-contrib-ldap-login

Comunicaciones Industriales

Nodo Modbus TCP

Nodos de modbusTCP:

Recomendado https://flows.nodered.org/node/node-red-contrib-modbus

Con el nodo https://flows.nodered.org/node/node-red-contrib-modbus no solo puedo leer modbus sino que puedo montar un servidor modbus.

Como usar este nodo:

Para leer datos lo mejor es usar modbus-flex-getter donde la entrada es un objeto json con estos datos:

  • unitid (0..255 tcp | 0..247 serial) – overrides default Unit-ID
  • fc (1..4)
  • start address (0:65535)
  • quantity (1:65535) of coils/inputs/registers to be read from the start address

Modbus-getter y Modbus-read indicas en el nodo los registros a leer. Importante: If you have more than 10 nodes on one communication configuration, use the Modbus-Flex-Getter or think about multiple connections to your Modbus device, please! You can do polling with the Modbus-Getter and Modbus-Flex-Getter, too by using an injecting node with an interval.

Vídeo manejar Modbus: https://www.youtube.com/watch?v=uillyhwBoEU 

Nodo Open PLC

Este paquete permite configurar e interactuar con una instancia de OpenPLC desde Node-RED.

Open-PLC: https://flows.nodered.org/node/node-red-contrib-openplc

Nodo OPC DA

Un nodo Node-RED para hablar con dispositivos de automatización utilizando el protocolo OPC-DA

Nodo: https://flows.nodered.org/node/node-red-contrib-opc-da

Nodo OPC UA

Nodos: 

KNX

Controle su instalación KNX a través de Node-Red. KNX IN/OUT de nodo único con importador de direcciones de grupo ETS opcional. Fácil de usar y altamente configurable.

KNX en Node-RED: https://flows.nodered.org/node/node-red-contrib-knx-ultimate

BBDD

Nodo MySQL

Un nodo Node-RED para leer y escribir en una base de datos MySQL

Nodo de mysql: https://flows.nodered.org/node/node-red-node-mysql

Código del nodo de mysql: https://github.com/node-red/node-red-nodes/tree/master/storage/mysql 

Ejemplo: https://flows.nodered.org/flow/13c55d1aa11e864609e24fa534a1fa26

Ejemplo de uso: https://tech.scargill.net/tag/mqtt-and-mysql-on-node-red/ 

Insertar en BBDD. Función, que inserta el texto, usuario y localización de payload:

 texto = msg.payload.text;
 localizacion = msg.payload.location;
 usuario = msg.payload.user
 msg.topic = "INSERT INTO `tabla` (`Texto`, `Localizacion`, `Usuario`) VALUES ('" + texto + "', '" + localizacion + "', '" + usuario + "')";
 return msg;

Nodo MongoDB

Un nodo Node-RED para guardar datos en una base de datos MongoDB.

Nodo MongoDB: https://flows.nodered.org/node/node-red-node-mongodb

SQL-Lite

Un nodo Node-Red para leer y escribir una base de datos sqlite local.

Flujo: https://flows.nodered.org/node/node-red-node-sqlite

SQL-lite https://randomnerdtutorials.com/sqlite-with-node-red-and-raspberry-pi/

Tutorial: http://developers.sensetecnic.com/article/using-sqlite-with-fred/

Nodo BBDD Connection Manager

Administrador de conexiones generalizado de Node-Red para permitir la agrupación de conexiones. 

Actualmente maneja los siguientes tipos de conexión:

  • postgreSQL
  • Casandra
  • DataStax
  • monetdb
  • neo4j
  • db2

Nodo: https://flows.nodered.org/node/node-red-contrib-connectionmanager

Nodo JSON DB

Nodo-RED Nodo para almacenar/recuperar fácilmente información almacenada en un archivo .json. Se implementa un almacenamiento en caché diferido para cargar la colección solo cuando sea necesario. Además, es posible configurar la colección para que solo escriba en el archivo json cuando Node-RED se detiene o se vuelve a implementar un flujo.

Nodo: https://flows.nodered.org/node/node-red-contrib-json-db

Ejemplo: https://flows.nodered.org/flow/fcd5e92e53d30abf73dcc9a21534e3d8 

Redes Sociales

Twitter

Nodo Twitter: https://flows.nodered.org/node/node-red-node-twitter

Nodo Twitter Stream: https://flows.nodered.org/node/node-red-contrib-twitter-stream 

Facebook

Nodo Facebook: https://flows.nodered.org/node/node-red-contrib-facebook

Nodo Facebook Messenger Writer: https://flows.nodered.org/node/node-red-contrib-facebook-messenger-writer 

Instagram

Nodo: https://flows.nodered.org/node/node-red-node-instagram 

IoT

Web Nodes

Una colección de nodos Node-RED para servicios web populares.

Paquete: https://flows.nodered.org/node/node-red-node-web-nodes 

Nodo no Oficial de Google Cloud

Nodo: https://flows.nodered.org/node/node-red-contrib-google-cloud 

Nodo TTN

Los nodos TTN para Node-RED reciben eventos y mensajes de dispositivos, así como también envían mensajes a los dispositivos.

TTN: https://www.thethingsnetwork.org/ 

Nodo: https://flows.nodered.org/node/node-red-contrib-ttn 

Decrypt Payload: https://flows.nodered.org/flow/845bb5b8cf788939dd261f472c289f77

Funciones en Node-RED

3 respuestas

El nodo Function te permite ejecutar cualquier código JavaScript contra el mensaje. Esto te da una completa flexibilidad en lo que haces con el mensaje, pero requiere familiaridad con JavaScript y es innecesario para muchos casos simples. 

Muchas veces existen nodos ya hechos para alguna función que deseemos hacer, si eres novato, antes de hacer una función busca en https://flows.nodered.org/ si hay algún nodo o flujo que lo haga.

El nodo función es un bloque de funciones de JavaScript que se ejecuta contra los mensajes que recibe el nodo. Los mensajes se pasan como un objeto JavaScript llamado msg.

Por convención, tendrá una propiedad msg.payload que contiene el cuerpo del mensaje, además de otras propiedades opcionales como msg.topic.

Se espera que la función devuelva un objeto de mensaje (o varios objetos de mensaje), pero puede optar por no devolver nada para detener un flujo.

La pestaña Setup contiene código que se ejecutará siempre que se inicie el nodo. La pestaña Close contiene código que se ejecutará cuando se detenga el nodo.

Desde la versión 1.1.0, el nodo Función proporciona una pestaña Configuración donde puede proporcionar código que se ejecutará siempre que se inicie el nodo. Esto se puede utilizar para configurar cualquier estado que requiera el nodo Función.

Por ejemplo, puede inicializar valores en contexto local que usará la función principal:

 if (context.get("counter") === undefined) {
     context.set("counter", 0)
 }

Tenga en cuenta que cada fragmento de código está en un ámbito separado; no puede declarar variables en uno y acceder a ellas en los demás. Necesitas usar el contexto para pasar cosas entre ellos.

La función de Setup puede devolver una Promise (promesa) si necesita completar un trabajo asincrónico antes de que la función principal pueda comenzar a procesar mensajes. Cualquier mensaje que llegue antes de que se complete la función de configuración se pondrá en cola y se manejará cuando esté listo.

Si usa código callback asíncrono en sus funciones, es posible que deba limpiar las solicitudes pendientes o cerrar cualquier conexión, cuando el nodo sea re-deployed. Puede hacer esto de dos formas diferentes.

O agregando un controlador de eventos en caso de close:

 node.on('close', function() {
     // tidy up any async code here - shutdown connections and so on.
 });

O, desde Node-RED 1.1.0, puede agregar código a la pestaña Close en el cuadro de diálogo de edición del nodo.

Las pestañas Setup y Close se ejecutan cuando se hace un deploy o al reiniciar Node-RED.

Mas información sobre escribir funciones en Node-RED:

Pros y contras de usar funciones en lugar de nodos: https://discourse.nodered.org/t/pros-and-cons-about-using-custom-functions-vs-the-basic-set-of-nodes/2959 

Otro nodo alternativo con procesos hijos es func-exec: https://flows.nodered.org/node/node-red-contrib-func-exec

Vídeo: https://www.youtube.com/watch?v=8XL3Zq1HjCo 

Escribir una Función

El código dentro del nodo Función representa el cuerpo de la función. La función más simple simplemente devuelve el mensaje exactamente como está: return msg;

Si la función devuelve un valor nulo, no se transmite ningún mensaje y el flujo finaliza.

La función siempre debe devolver un objeto msg. Devolver un número o una cadena resultará en un error.

El objeto del mensaje devuelto no necesita ser el mismo objeto que se pasó; la función puede construir un objeto completamente nuevo antes de devolverlo. La construcción de un nuevo objeto de mensaje perderá todas las propiedades del mensaje recibido. Esto interrumpirá algunos flujos, por ejemplo, el flujo de entrada/respuesta HTTP requiere que las propiedades msg.req y msg.res se conserven de un extremo a otro. En general, los nodos de función deben devolver el objeto de mensaje que se les pasó después de haber realizado cambios en sus propiedades.

Función que devuelve un nuevo mensaje eliminando las propiedades del mensaje original:

 var newMsg = { payload: msg.payload.length };
 return newMsg;

Ejemplo, crear una función que pase el payload y el topic a mayúsculas:

 var payload=msg.payload; //get payload
 msg.payload=payload.toUpperCase(); //convert to uppercase
 var topic=msg.topic; //get topic
 msg.topic=topic.toUpperCase();//convert to uppercase
 return msg;

Enviando mensajes

La función puede devolver los mensajes que quiere pasar a los siguientes nodos del flujo con return o puede llamar a node.send (mensajes).

Puede devolver o enviar:

  • un objeto de mensaje único: se pasa a los nodos conectados a la primera salida
  • una matriz de objetos de mensaje: se pasa a los nodos conectados a las salidas correspondientes (múltiples salidas)

Si algún elemento de la matriz es en sí mismo una matriz de mensajes, se envían varios mensajes a la salida correspondiente.

Si se devuelve un valor nulo, ya sea por sí mismo o como un elemento de la matriz, no se transmite ningún mensaje.

Múltiples Salidas

El diálogo de edición de funciones permite cambiar el número de salidas. Si hay más de una salida, la función puede devolver una matriz de mensajes para enviar a las salidas.

Esto facilita escribir una función que envíe el mensaje a diferentes salidas dependiendo de alguna condición. Por ejemplo, esta función enviaría cualquier cosa sobre el tema banana a la segunda salida en lugar de a la primera:

 if (msg.topic === "banana") {
    return [ null, msg ];
 } else {
    return [ msg, null ];
 }

El siguiente ejemplo pasa el mensaje original tal cual en la primera salida y un mensaje que contiene la longitud de la carga útil se pasa a la segunda salida:

 var newMsg = { payload: msg.payload.length };
 return [msg, newMsg];

Ejemplo. Usamos dos nodos inject para inyectar un mensaje sobre dos temas diferentes en un nodo de función con dos salidas. La función envía el mensaje a la salida según el nombre del tema. El tema test1 va a output1 y test2 va a output2.

Código:

 var topic=msg.topic;
 if (topic=="test1"){
     return [msg,null];
 }
 if (topic=="test2"){
     return [null,msg];
 }

Múltiples Mensajes

Una función puede devolver varios mensajes en una salida al devolver una matriz de mensajes dentro de la matriz devuelta. Cuando se devuelven varios mensajes para una salida, los nodos posteriores recibirán los mensajes uno a uno en el orden en que se devolvieron.

En el siguiente ejemplo, msg1, msg2, msg3 se enviarán a la primera salida y msg4 se enviará a la segunda salida.

 var msg1 = { payload:"first out of output 1" };
 var msg2 = { payload:"second out of output 1" };
 var msg3 = { payload:"third out of output 1" };
 var msg4 = { payload:"only message from output 2" };
 return [ [ msg1, msg2, msg3 ], msg4 ];

El siguiente ejemplo divide la carga útil recibida en palabras individuales y devuelve un mensaje para cada una de las palabras.

 var outputMsgs = [];
 var words = msg.payload.split(" ");
 for (var w in words) {
     outputMsgs.push({payload:words[w]});
 }
 return [outputMsgs];

Ejemplo. Usar un nodo inject para inyectar una cadena de prueba en el nodo de función. El nodo de función toma la cadena, pero en lugar de enviar 1 mensaje, tiene un bucle for que crea 3 mensajes y los coloca en un array.

Código:

 var m_out=[]; //array for message objects
 var message=msg.payload;
 for (i=0;i<3;i++){
     message=message+i; //add count to message
     var newmsg={payload:message,topic:msg.topic}
     m_out.push(newmsg);
 }
 return [m_out];

Enviar mensajes de forma asincrónica

Si la función necesita realizar una acción asincrónica antes de enviar un mensaje, no puede devolver el mensaje al final de la función con return.

En su lugar, debe hacer uso de la función node.send(), pasando los mensajes que se enviarán.

Por ejemplo:

 doSomeAsyncWork(msg, function(result) {
     msg.payload = result;
     node.send(msg);
 });
 return;

Esto es útil, por ejemplo, al recorrer una matriz u objeto y enviar datos a medida que se leen. Por ejemplo:

 count=0;
 for(var i=0;i<10;i++)
 {
 msg.payload=count;
 node.send(msg)
 count+=1; 
 }

Ejemplo: ver como al mandar send, los mensajes se procesan de forma simultánea al ser asíncrono:

 for(var i=0;i<10;i++) {
     msg.payload=i;
     await new Promise(r => setTimeout(r, 1000)); //sleep(1000)
     node.send(msg);
 }

Desde la versión Node-RED 1.0, el nodo Función clonará cada objeto de mensaje que pase a node.send para garantizar que no haya modificaciones no intencionales de los objetos de mensaje que se reutilicen en la función.

La función puede solicitar al tiempo de ejecución (runtime) que no clone el primer mensaje pasado a node.send pasando falso como segundo argumento de la función. Haría esto si el mensaje contiene algo que de otra manera no se puede clonar, o por razones de rendimiento para minimizar la sobrecarga de enviar mensajes: node.send(msg,false);

Si un nodo Función realiza un trabajo asincrónico con un mensaje, el tiempo de ejecución no sabrá automáticamente cuándo ha terminado de manejar el mensaje.

Para ayudarlo a hacerlo, el nodo Función debe llamar a node.done() en el momento apropiado. Esto permitirá que el tiempo de ejecución rastree correctamente los mensajes a través del sistema.

 doSomeAsyncWork(msg, function(result) {
     msg.payload = result;
     node.send(msg);
     node.done();
 });
 return;

Registro y manejo de errores

Para registrar cualquier información o reportar un error, las siguientes funciones están disponibles:

  • node.log(«Log message»)
  • node.warn(«Warning»)
  • node.error(«Error»)

Los mensajes de warn y error también se envían a la pestaña de debug del editor de flujo.

Para un registro más fino, también están disponibles node.trace() y node.debug(). Si no hay ningún logger configurado para capturar esos niveles, no se verán.

Si la función encuentra un error que debería detener el flujo actual, no debería devolver nada. El nodo Catch se puede utilizar para manejar errores. Para invocar un nodo Catch, pase msg como segundo argumento a node.error: node.error(«Error», msg);

Acceder a la información del nodo

En el bloque de funciones, se puede hacer referencia a la identificación y el nombre del nodo mediante las siguientes propiedades:

  • node.id – id del nodo
  • node.name – nombre del nodo

Uso de variables de entorno

Se puede acceder a las variables de entorno usando: env.get («MY_ENV_VAR»).

Variables de entorno: https://nodered.org/docs/user-guide/environment-variables 

Almacenamiento de datos

Aparte del objeto msg, la función también puede almacenar datos en el almacén de contexto: https://nodered.org/docs/user-guide/context 

En el nodo Función hay tres variables predefinidas que se pueden usar para acceder al contexto:

  • context: el contexto local del nodo
  • flow: el contexto del alcance del flujo
  • global: el contexto de alcance global

Estas variables predefinidas son una característica del nodo Función y no se usan en la creación de nodos.

Hay dos modos de acceder al contexto; ya sea sincrónico o asincrónico. Los almacenes de contexto integrados proporcionan ambos modos. Es posible que algunos almacenes solo den acceso asincrónico y arrojará un error si se accede a ellas de manera sincrónica.

Para obtener un valor del contexto: var myCount = flow.get(«count»);

Para establecer un valor: flow.set(«count», 123);

El siguiente ejemplo mantiene un recuento de cuántas veces se ha ejecutado la función:

 // initialise the counter to 0 if it doesn't exist already
 var count = context.get('count')||0;
 count += 1;
 // store the value back
 context.set('count',count);
 // make it part of the outgoing msg object
 msg.count = count;
 return msg;

get/set multiples valores:

 var values = flow.get(["count", "colour", "temperature"]);
 // values[0] is the 'count' value
 // values[1] is the 'colour' value
 // values[2] is the 'temperature' value
 flow.set(["count", "colour", "temperature"], [123, "red", "12.5"]);

El contexto global se puede rellenar previamente con objetos cuando se inicia Node-RED. Esto se define en el archivo principal settings.js bajo la propiedad functionGlobalContext.

Esto se puede utilizar para cargar módulos adicionales dentro del nodo Función: https://nodered.org/docs/user-guide/writing-functions#loading-additional-modules 

Acceso al contexto asincrónico

Si el almacén de contexto requiere acceso asincrónico, las funciones get y set requieren un parámetro de devolución de llamada adicional.

 // Get single value
 flow.get("count", function(err, myCount) { ... });
 // Get multiple values
 flow.get(["count", "colour"], function(err, count, colour) { ... })
 // Set single value
 flow.set("count", 123, function(err) { ... })
 // Set multiple values
 flow.set(["count", "colour", [123, "red"], function(err) { ... })

El primer argumento pasado a la callback, err, solo se establece si ocurrió un error al acceder al contexto.

La versión asincrónica del ejemplo de recuento se convierte en:

 context.get('count', function(err, count) {
     if (err) {
         node.error(err, msg);
     } else {
         // initialise the counter to 0 if it doesn't exist already
         count = count || 0;
         count += 1;
         // store the value back
         context.set('count',count, function(err) {
             if (err) {
                 node.error(err, msg);
             } else {
                 // make it part of the outgoing msg object
                 msg.count = count;
                 // send the message
                 node.send(msg);
             }
         });
     }
 });

Múltiples Almacenes de Contexto

Es posible configurar múltiples almacenes de contexto. Por ejemplo, se podría utilizar un almacén basado en memoria y en archivos.

Las funciones de contexto get/set aceptan un parámetro opcional para identificar el almacén a utilizar.

 // Get value - sync
 var myCount = flow.get("count", storeName);
 // Get value - async
 flow.get("count", storeName, function(err, myCount) { ... });
 // Set value - sync
 flow.set("count", 123, storeName);
 // Set value - async
 flow.set("count", 123, storeName, function(err) { ... })

Añadir Estado

El nodo de función también puede proporcionar su propia decoración de estado de la misma forma que otros nodos. Para establecer el estado, llame a la función node.status. Por ejemplo:

 node.status({fill:"red",shape:"ring",text:"disconnected"});
 node.status({fill:"green",shape:"dot",text:"connected"});
 node.status({text:"Just text status"});
 node.status({});   // to clear the status

Para los parámetros aceptados en el estado ver https://nodered.org/docs/creating-nodes/status

  • fill – red, green, yellow, blue or grey
  • shape – Ring or Dot

Las actualizaciones de estado también pueden ser capturadas por el nodo Estado.

Carga de módulos adicionales

Si se necesita usar un módulos de node.js es necesario activarlos previamente. Los módulos de nodo adicionales no se pueden cargar directamente dentro de un nodo de función. Deben cargarse en el archivo settings.js y agregarse a la propiedad functionGlobalContext.

Por ejemplo, el módulo del sistema operativo integrado puede estar disponible para todas las funciones agregando lo siguiente al archivo settings.js.

 functionGlobalContext: {
     osModule:require('os')
 }

En ese momento, se puede hacer referencia al módulo dentro de una función como global.get (‘osModule’).

Los módulos cargados desde el archivo de configuración deben instalarse en el mismo directorio que el archivo de configuración. Para la mayoría de los usuarios, ese será el directorio de usuario predeterminado: ~/.node-red: 

 cd ~/.node-red
 npm install name_of_3rd_party_module

Reusar Nodos de Función

Se pueden guardar los nodos de función en la library y reutilizarlos en otros flujos importándolos. Para guardar una función en la library, haga doble clic en la función para editarla y haga clic en el icono de marcador junto al nombre de la función. Aparece un menú desplegable para importar o guardar la función.

También se puede utilizar un subflow para almacenar funciones. El uso de un subflujo los hace disponibles como nodos que puede seleccionar en la paleta de nodos de la izquierda.

Otros Objetos Disponibles

Objetos disponibles en el nodo función:

context

  • context.get(..): get a node-scoped context property
  • context.set(..): set a node-scoped context property
  • context.keys(..): return a list of all node-scoped context property keys
  • context.flow : same as flow
  • context.global : same as global

flow

  • flow.get(..) : get a flow-scoped context property
  • flow.set(..) : set a flow-scoped context property
  • flow.keys(..) : return a list of all flow-scoped context property keys

global

  • global.get(..) : get a global-scoped context property
  • global.set(..) : set a global-scoped context property
  • global.keys(..) : return a list of all global-scoped context property keys

RED

  • RED.util.cloneMessage(..) : safely clones a message object so it can be reused

env

  • env.get(..) : get an environment variable

El nodo Función también pone a disposición los siguientes módulos y funciones:

  • Buffer – the Node.js Buffer module
  • console – the Node.js console module (node.log is the preferred method of logging)
  • util – the Node.js util module
  • setTimeout/clearTimeout – the javascript timeout functions.
  • setInterval/clearInterval – the javascript interval functions.

Proyectos en Node-RED

3 respuestas

Los proyectos son una nueva forma de administrar sus archivos de flujo. En lugar de tratar sus flujos como un simple par de archivos (flows_localhost.json y flows_localhost_cred.json), ellos representan todo lo que necesita para crear una aplicación Node-RED redistribuible.

Los proyectos están respaldados por un repositorio de git, lo que significa que todos los archivos están completamente controlados por versiones y permiten a los desarrolladores usar flujos de trabajo similares para colaborar con otros.

Esta característica está disponible desde la versión 0.18: https://nodered.org/blog/2018/01/31/version-0-18-released

Introducción a proyectos en Node-RED: https://www.youtube.com/watch?v=Bto2rz7bY3g 

Para habilitar la función de proyectos, edite su archivo settings.js y agregue la siguiente opción dentro del bloque module.exports y reinicie Node-RED.

 editorTheme: {
        projects: {
            enabled: true
        }
    },

La función se basa en tener disponibles las herramientas de línea de comandos git y ssh-keygen. Node-RED los buscará al inicio y le informará si faltan.

Si no se habilita, en el arranque sale: [warn] Projects disabled : editorTheme.projects.enabled=false

La función de proyectos ahora ofrece una opción para un flujo de trabajo de git simplificado. La opción, en Configuración de usuario, le permite habilitar un modo «automático» donde los cambios se confirmarán (commit) automáticamente con cada implementación.

Más información: https://nodered.org/docs/user-guide/projects/

Crear el Primer Proyecto

Cuando abras el editor, serás recibido por una pantalla de bienvenida que te invita a crear tu primer proyecto utilizando tus archivos de flujo existentes.

Configurar el Cliente de Control de Versiones

Node-RED utiliza la herramienta de código abierto Git para el control de versiones. Realiza un seguimiento de los cambios en los archivos de su proyecto y le permite enviarlos a repositorios remotos como github. Cuando realiza un conjunto de cambios, Git registra quién realizó los cambios con un nombre de usuario y una dirección de correo electrónico. El nombre de usuario puede ser el que desee, no es necesario que sea el nombre real.

Puede cambiar la configuración de Git en cualquier momento a través del cuadro de diálogo principal de configuración de Node-RED.

Crear un Proyecto

El siguiente paso permite nombrar su proyecto y darle una descripción.

Crear Archivos de Proyecto

Node-RED migrará automáticamente los archivos de flujo existentes al proyecto. Puede elegir cambiarles el nombre.

Configurar el Cifrado del Archivo de Credenciales

Se puede compartir el proyecto en sitios públicos como GitHub, se recomienda que cifre su archivo de credenciales. Para cifrarlo, se debe elegir una clave que se utilizará para proteger el archivo. Esta clave no se almacena dentro del proyecto. Si alguien más clona el proyecto, deberá proporcionar la clave para descifrar el archivo de credenciales. De lo contrario, deberán editar el flujo para proporcionar sus propias credenciales.

A continuación, se crea el proyecto en el directorio: ~/.node-red/projects/<nombre-proyecto>

Una vez se haya creado el proyecto, se puede continuar usando el editor Node-RED como siempre. Hay algunas partes nuevas del editor que se han agregado para trabajar con su proyecto como la parte de control de versiones.

Puede haber tantos proyectos como queramos. Si un proyecto está activo, el resto no funciona. SOLO PUEDE HABER UN PROYECTO ACTIVO.

¿Cómo sabe Node-RED que proyecto está activo? en el fichero .config.projects.json  pone cual es el active project y además los proyectos que hay en esa instancia de Node-RED, en este fichero se ve la contraseña de cifrado del proyecto en texto plano!!!

En .config.users.json tenemos los usuario y los datos de git.

Trabajar con Proyectos

La barra lateral de información ahora muestra en qué proyecto está trabajando en la parte superior. Junto al nombre del proyecto hay un botón que abre el cuadro de diálogo Configuración del proyecto.

Hay tres tabs:

  • Project – lets you edit the project’s README.md file.
  • Dependencies – manage the list of node modules your project depends on
  • Settings – manage the project settings, including the git remotes

Cada proyecto tiene su propio archivo package.json que incluye una lista de módulos de nodo de los que depende el proyecto. El editor Node-RED realiza un seguimiento de los nodos que está utilizando en un flujo y ayuda a mantener actualizada esa lista de dependencias.

Mantener la lista de dependencias actualizada es importante si desea compartir el proyecto con otros, ya que ayudará a los usuarios a instalar los módulos necesarios.

La pestaña de configuración del proyecto permite administrar los archivos de flujo, la configuración de cifrado de sus credenciales y configurar las ramas git locales y repositorios remotos.

Control de Versiones

Se ha agregado una nueva pestaña de history a la barra lateral. Aquí es donde se administra el control de versiones del proyecto. La pestaña tiene dos secciones:

  • Cambios locales: muestra los archivos del proyecto que han cambiado, lo que permite organizarlos y confirmarlos.
  • Historial de commits: una lista de todos los commits en el repositorio, con herramientas para enviar commits a repositorios remotos.

Siempre que cambie un archivo de proyecto, por ejemplo, al hacer un deploy de flujo, aparecerá en la sección «Archivos locales». Puede hacer clic en el nombre del archivo para ver una diferencia de lo que ha cambiado. Cuando coloque el cursor sobre el archivo, verá un botón +; al hacer clic en él, se ubicará el archivo y lo moverá hacia abajo a la lista «Cambios para confirmar».

Cuando haya preparado los archivos que desea confirmar, haga clic en el botón commit, añadir un mensaje y confirmar.

La sección del historial de commits enumera todas las confirmaciones en la rama actual del repositorio. Cuando crea un proyecto, Node-RED confirma automáticamente el conjunto inicial de archivos predeterminados para el proyecto.

En la parte superior de la lista se encuentra el botón «Branch». Eso le permite chekout/crear ramas dentro del repositorio.

Si el repositorio tiene un repositorio remoto configurado, también hay un botón que muestra cuántos commits adelante y/o detrás del repositorio local se comparan con el remoto. Permite elegir el control de rama remota para rastrear y push/pull de los cambios al control remoto.

Esta es un área que el editor de Node-RED intenta simplificar la experiencia del usuario y no expone todas las diversas opciones que proporciona git. Por ejemplo, no proporciona opciones para reajustar sus commits locales o forzar push de cambios en el control remoto. Aún puede hacer esas cosas volviendo a la línea de comandos.

Crear Nuevos Proyectos

Desde Projects -> New es posible crear nuevos proyectos y dispone de tres opciones:

  • Abrir un proyecto existente
  • Crear un nuevos proyecto
  • Clonar un proyecto de un repositorio

Node-RED solo ejecuta un proyecto a la vez. Al abrir otro proyecto, cambia los flujos que se están ejecutando.

La vista «proyecto abierto» también permite eliminar proyectos colocando el cursor sobre ellos en la lista y haciendo clic en el botón Eliminar. No puede eliminar el proyecto activo.

Clonar un proyecto de un repositorio, permite clonar un repositorio remoto existente. Puede usar una URL http(s) o git/ssh para el repositorio. Si el repositorio requiere autenticación, debe proporcionarse en esta opción. Actualmente, Node-RED no utiliza ningún asistente de credenciales con el que pueda estar configurado el cliente git.

Para conectar con la cuenta de github simplemente poner usuario y contraseña, pero si tengo activado el 2FA debo crea un token como se indica aquí: https://www.amitmerchant.com/using-github-password-terminal-2fa/

Para git/ssh, Node-RED ofrecerá una lista de claves públicas ssh disponibles. Esta lista se genera escaneando ~/.ssh en busca de archivos que terminen en .pub y que tengan los archivos de clave privada correspondientes. También le permite generar un nuevo par de claves pública/privada a través de la pestaña «Git config» del cuadro de diálogo de configuración principal. Estos archivos se almacenan en ~ /.node-red/projects/.sshkeys /. Si tiene adminAuth habilitado, los archivos se asignan al usuario que ha iniciado sesión actualmente, por lo que no es necesario que comparta las credenciales para el control remoto.

Más información en https://binnes.github.io/Node-RED-container-prod/Node-REDsourceControl/index.html

Manejar multiproyectos: https://flows.nodered.org/node/node-red-contrib-multiproject (no testeado)

Ejemplo

Probar a clonar estos proyectos sin la clave:

Cuando se clone, avisará de un error que no hay clave de cifrado o es incorrecta, entonces hay que ir a “Project Settings” y en settings poner una nueva clave de cifrado.

Una vez puesta la nueva clave de cifrado, tendremos el flujo completo, pero los datos de contraseñas no se habrán importado y habrá que ponerlos a mano, editando los nodos de configuración y los nodos que correspondan.

En el caso que en el flujo clonado haya un nodo que no se haya instalado avisará del error para que se instale.

Si proporciona la clave correcta, el clonado también incluye los usuarios y contraseñas y puede usarse directamente el flujo si se tienen instaladas todas las dependencias.

Automatizar Proyectos

La opción de proyectos me permite distribuir de forma automatizada usando git, el código publicado en otras instancias de Node-RED, ya sea de un entorno de desarrollo a uno de producción una vez testeado o bien de un entorno de producción a múltiples entornos de producción.

En el caso que deseemos distribuir un mismo código a múltiples nodos que hace la misma tarea, se puede automatizar usando git y hacer las diferencias de variables de cada nodo usando las variables de entorno de cada nodo.

Esto es interesante en un entorno con múltiples instancias de Node-RED distribuidas (nodos) que deseemos actualizar de forma automatizada. Por ejemplo, nodos en diversas instalaciones que recogen datos de PLCs y los mandan a una BBDD central, para ello hacemos un push al repositorio y luego desde cada nodo un pull que recoja la actualización y luego hacer el deploy por comando (o reinicio de Node-RED) para actualizar el nodo remoto.

Sistema de automatización de control de versiones y backup a través de git:

  • Copia por flujo o total en directorio que tenga git y haga un pull
  • Guardar los cambios de forma manual o sino automática usando la API en un proceso periodico
  • luego usar CI cada vez que se haga deploy

Nota de como hacer backup de Node-RED: https://github.com/langanjp/PI-NodeRed/wiki/Node-RED-Backup

Mejoras Futuras

Obtenido de https://nodered.org/blog/2020/10/13/future-plans

We have had the projects feature in Node-RED for a long time now – bringing the ability to version control flows directly into the editor. But there’s more to be done in this area.

The 1.2 release has introduced a new simplified git workflow – where changes are automatically committed whenever the deploy button is clicked. That’s important for users who are less experienced with Git version control – they will benefit without having to know about committing changes themselves.

And there are other areas we need to improve:

  • Managing project dependencies. At the moment the editor lets you edit the dependencies yourself, and it tries to give some hints on what needs doing, but that whole user experience needs to be improved.
  • Accessing earlier versions of a project. Having a full history of changes is not much use if you can’t easily go back to an earlier version. It is possible to do on the command-line – but that isn’t the right answer if we want this to be accessible to all users within the editor.
  • Adding settings.js to a project. For a project to be a complete deployable artefact, it needs a settings file. At the moment, that has to be created and added to the project manually. There’s more the editor could do to help with this – the hard part is managing the project’s settings file versus the runtime settings file – but that’s a discussion for another time.
  • Adding a Dockerfile to a project. A common pattern for deploying projects into a production environment is via some form of containerisation. Making this quick and easy to setup in the editor would be a big step forward – although very much an optional feature.

I’m sure there are other things we could be doing with the Projects feature to make it much more powerful. As with everything on this roadmap, we’ll be looking to the community for feedback to help expand on the details.

Contexto y Variables de Entorno en Node-RED

3 respuestas

Contexto

En Node-RED, una consideración es cómo administrar cualquier información de estado en sus flujos. Por ejemplo, llevar un recuento de cuántos mensajes pasan por un flujo o el estado actual de un sensor externo.

Node-RED proporciona el sistema de contexto para administrar el estado dentro del tiempo de ejecución. El contexto puede tener el alcance de la misma pestaña, subflujo o estar disponible globalmente.

Si solo los nodos de una pestaña en particular necesitan una parte de la información de estado, debe utilizar un ámbito de flujo en lugar de global. También debe elegir con cuidado los nombres de las variables de contexto; asegúrese de que sean descriptivos y fáciles de identificar.

Si un solo nodo necesita acceder a un valor, como un nodo de función o un contador, el contexto de nodo es suficiente.

Otra opción es administrar el estado fuera de Node-RED, como usar mensajes MQTT retenidos o una base de datos de algún tipo. Esas opciones agregan una dependencia externa para administrar y no están tan convenientemente integradas como las variables de contexto, pero también se pueden usar junto con el contexto y no como un reemplazo completo. Por ejemplo, cuando desee compartir la información de estado en varias instancias de Node-RED, o en el caso de MQTT, poder activar un flujo siempre que cambie un valor.

Documentación oficial: https://nodered.org/docs/user-guide/context 

Api context: https://nodered.org/docs/api/context/

Node-RED proporciona una forma de almacenar información que se puede compartir entre diferentes nodos sin utilizar los mensajes que pasan por un flujo. Esto se llama «contexto».

En node-red se puede trabajar con variables de contexto:

  • Contexto – solo aplica a un nodo
  • Flujo – aplica solo al flujo
  • globales – aplica a todo.

Por defecto, Node-RED utiliza un almacén de contexto en memoria, los valores no se guardan entre reinicios. Se puede configurar para usar un almacén basado en el sistema de archivos para que los valores sean persistentes. También es posible conectar complementos de almacenamiento alternativos.

Node-RED proporciona dos módulos integrados para esto: memory y localfilesystem. Es posible configurar Node-RED para guardar datos de contexto en disco para que esté disponible en todos los reinicios, se almacena en caché los valores en la memoria y solo los escribe en el sistema de archivos cada 30 segundos.

La forma más fácil de establecer un valor en contexto es usar el nodo Change. Por ejemplo, la siguiente regla de cambio de nodo almacenará el valor de msg.payload en el contexto de flujo bajo la clave de myData.

Varios nodos pueden acceder al contexto directamente. Por ejemplo, el nodo Inject puede configurarse para inyectar un valor de contexto y el nodo Switch puede enrutar mensajes en función de un valor almacenado en contexto.

El contexto se puede eliminar de forma permanente mediante el uso de un conjunto de nodos Change para eliminar o desde la barra lateral en la pestaña “Context Data”

Mas información: http://www.steves-internet-guide.com/node-red-variables/ 

La barra lateral de contexto muestra el contenido del almacén de datos de contexto. El panel se divide en tres secciones, una para cada ámbito de contexto; nodo, flujo y global. Se debe hacer clic en el botón de actualización para cargar el contenido del contexto.

Las secciones Nodo y Flujo tienen una casilla de verificación junto a su botón de actualización para activar la actualización automática de los contenidos cada vez que cambia el nodo o flujo seleccionado.

Al pasar el mouse sobre cualquier nombre de propiedad de contexto, se mostrará un botón de actualización que se puede usar para actualizar solo ese valor.

Al pasar el cursor sobre el valor de una propiedad de contexto, se mostrará un botón para copiar su contenido en el portapapeles del sistema.

Addon para ver el context en node red: https://flows.nodered.org/node/node-red-contrib-contextbrowser

Varios nodos pueden acceder al contexto directamente. Por ejemplo, el nodo Inject puede configurarse para inyectar un valor de contexto y el nodo Switch puede enrutar mensajes en función de un valor almacenado en contexto.

Nodo para almacenar información de configuración en una ubicación central y usarla para establecer propiedades de contexto de flujo y globales al inicio (fase de inicialización) o durante el tiempo de ejecución. Se pueden usar varios nodos de configuración para almacenar ajustes de configuración alternativos y cambiar entre ellos durante el tiempo de ejecución: https://flows.nodered.org/node/node-red-contrib-config 

Ejemplo, enrutar un mensaje en función del valor de una variable de contexto: https://cookbook.nodered.org/basic/route-on-context 

Variables de Entorno

Las variables de entorno se pueden utilizar más ampliamente dentro de Node-RED para crear flujos que se pueden personalizar para diferentes plataformas sin tener que realizar cambios manuales.

Por ejemplo, puede tener un flujo que planea ejecutar en varios dispositivos, pero cada dispositivo debe suscribirse a su propio tema MQTT único.

Al igual que en el ejemplo de subflujo, puede configurar el nodo MQTT para publicar en $ {MY_TOPIC} y luego establecerlo como una variable de entorno antes de ejecutar Node-RED. Eso permite que esas personalizaciones específicas del dispositivo se mantengan por separado de los flujos que deberían ser comunes a todos los dispositivos.

Se puede usar el mismo enfoque cuando los flujos pueden ejecutarse en diferentes sistemas operativos, donde la ruta a un archivo utilizado por los flujos puede ser diferente según el sistema operativo.

Los nodos Inject y Change pueden acceder a las variables de entorno utilizando la opción «env» en su TypedInput. El nodo Función puede usar la función env.get ().

Trabajar con variables de entorno:

Cualquier propiedad de nodo se puede establecer con una variable de entorno estableciendo su valor en una cadena de la forma ${ENV_VAR}. Cuando el tiempo de ejecución carga los flujos, sustituirá el valor de esa variable de entorno antes de pasarla al nodo.

Esto solo funciona si reemplaza toda la propiedad; no se puede usar para reemplazar solo una parte del valor. Por ejemplo, no es posible utilizar CLIENT-${HOST}

Como los nodos proporcionan su propio diálogo de edición, no todas las propiedades proporcionarán una entrada de texto que se pueda utilizar para introducir la cadena env-var. En ese caso, puede considerar editar manualmente el archivo de flujo para establecer la propiedad.

No puede establecer variables de entorno en tiempo de ejecución. Solo se evalúan cuando se inician los flujos.

El tiempo de ejecución obtiene sus valores antes de pasarlos a nodos individuales. Los nodos no saben que el valor proviene de una variable de entorno. Si cambia una var env, no hace que mágicamente el nodo cambie su configuración. Debería reiniciar Node-RED para recoger los cambios.

Una forma de configurar las variables de entorno es en su archivo settings.js.

Lo siguiente establecerá la variable de entorno MY_ENV_VAR: process.env.MY_ENV_VAR = «Hello World»;

Puede agregar líneas como esa en la parte superior de su archivo de configuración.

La otra opción es configurarlos completamente fuera de Node-RED en el shell en el que está ejecutando Node-RED. Cómo lo haga dependerá de su sistema operativo y de cómo esté ejecutando Node-RED.

Nodo para leer variables de entorno https://flows.nodered.org/node/node-red-contrib-env

Ejemplo de uso de env var: https://flows.nodered.org/flow/8a13d11dfe80e279df83341e3e17bcc1 

Usando el Widget TypedInput

Dentro del editor, el widget TypedInput puede ofrecer «variable de entorno» como tipo. Cuando se selecciona este tipo, su valor se evaluará de la siguiente manera:

  • si no hay $ {} presente, usa el valor completo como el nombre de la variable de entorno. Por ejemplo, «FOO» se reemplazará con el valor de process.env.FOO
  • si $ {} está presente, sustituirá la variable de entorno correspondiente en el resultado: por ejemplo, dado el valor «Hola ${FOO}» y la var env FOO se establece en Mundo, esto da como resultado el valor «Hola mundo»

Variables de Entorno en Subflows

Desde 0.20, los subflujos se pueden configurar con propiedades de instancia. Estos aparecen como variables de entorno dentro del subflujo y se pueden personalizar para instancias individuales del subflujo.

Por ejemplo, dada una API REST que proporciona acceso a diferentes tipos de registro, se podría crear un subflujo para acceder a la API y manejar la respuesta, utilizando una variable de entorno para identificar a qué tipo de registro se debe acceder. Las instancias individuales del subflujo se pueden personalizar para esos tipos particulares.

Almacenamiento de Contexto

Por defecto, el contexto se almacena sólo en la memoria. Esto significa que su contenido se borra cada vez que se reinicia el Node-RED. Con la versión 0.19, es posible configurar Node-RED para guardar datos de contexto de modo que estén disponibles en los reinicios.

La propiedad contextStorage de settings.js puede utilizarse para configurar cómo se almacenan los datos de contexto.

Node-RED proporciona dos módulos incorporados para ello: memory y localfilesystem. También es posible crear plugins de almacenamiento personalizados para guardar los datos en otro lugar.

Para habilitar el almacenamiento basado en archivos, se puede utilizar la siguiente opción:

 contextStorage: {
    default: {
        module: "localfilesystem"
    }
 }

Esto establece que el almacén contextual por defecto sea una instancia del plugin localfilesystem, con todos sus ajustes por defecto. Esto significa que:

  • almacenará los datos de contexto en archivos bajo ~/.node-red/context/
  • almacena los valores en la memoria y sólo los escribe en el sistema de archivos cada 30 segundos.

Es posible configurar más de un almacén para que algunos valores se guarden en el sistema de archivos local y otros sólo se mantengan en la memoria.

Por ejemplo, para configurar el almacén predeterminado para que sólo esté en memoria, y un segundo almacén para el sistema de archivos, se pueden utilizar las siguientes opciones:

 contextStorage: {
    default: "memoryOnly",
    memoryOnly: { module: 'memory' },
    file: { module: 'localfilesystem' }
 }

En este ejemplo, la propiedad por defecto le dice a Node-RED que guarde en memoria el contexto, si una solicitud de acceso al contexto no especifica un almacenamiento concreto.

Los detalles completos de los módulos incorporados, las opciones de configuración que ofrecen y cómo crear módulos personalizados, están disponibles en las páginas de la API: https://nodered.org/docs/api/context/

Opciones de guardado en fichero local el contexto: https://nodered.org/docs/api/context/store/localfilesystem

Varios nodos pueden acceder directamente al contexto. Por ejemplo, el nodo Inject puede configurarse para inyectar un valor de contexto y el nodo Switch puede enrutar mensajes basados en un valor almacenado en el contexto.

Si tiene varios almacenes de contexto configurados, la interfaz de usuario le permitirá elegir en qué almacén debe almacenarse un valor.

El contexto puede ser eliminado permanentemente usando un nodo de change establecido para eliminarlo.

Si se guarda en disco, los datos de las variables de contexto se almacenan en el directorio: .node-red/context

Se debe tener en cuenta que los datos se guardan en disco cada 30 segundos, lo que puede ser suficiente para algunas aplicaciones, pero para otras no.

Para hacer mediante código, debe hacerse set la variable de contexto a undefined.

Por ejemplo, para eliminar todas las variables del contexto de flow:

 var keys = flow.keys();
 keys.forEach(element => flow.set(element,undefined));

Más información: https://nodered.org/docs/user-guide/context#context-stores

Nodos de Configuración en Node-RED

4 respuestas

Un nodo de configuración (config) es un tipo especial de nodo que contiene una configuración reutilizable que puede ser compartida por nodos regulares en un flujo.

Los nodos de configuración se agregan a través del cuadro de diálogo de edición de un nodo que requiere el nodo de configuración. Tendrá un campo para seleccionar entre los nodos de configuración disponibles del tipo requerido o para agregar una nueva instancia.

Al hacer clic en el botón junto al cuadro de selección, se abrirá el cuadro de diálogo de edición para el nodo seleccionado o se agregará una nueva instancia del nodo de configuración.

El cuadro de diálogo de edición del nodo de configuración solo tiene las propiedades del nodo y las pestañas de descripción, ya que un nodo de configuración no tiene icono ni puertos para establecer etiquetas.

En el pie de página del diálogo hay una indicación de cuántos nodos usan este nodo de configuración. También proporciona un cuadro de selección para establecer el alcance del nodo de configuración. El alcance determina en qué flujos está disponible el nodo de configuración. De forma predeterminada, está disponible en todos los flujos, pero el cuadro de selección se puede utilizar para que sea local para un solo flujo.

Al igual que con los nodos normales, también se puede habilitar o deshabilitar usando el botón de alternar en el pie de página.

Algunos nodos necesitan compartir la configuración. Por ejemplo, los nodos MQTT In y MQTT Out comparten la configuración del intermediario MQTT, lo que les permite agrupar la conexión. Los nodos de configuración tienen un alcance global de forma predeterminada, esto significa que el estado se compartirá entre los flujos.

Un uso común de los nodos de configuración es representar una conexión compartida a un sistema remoto. En ese caso, el nodo de configuración también puede ser responsable de crear la conexión y ponerla a disposición de los nodos que usan el nodo de configuración. En tales casos, el nodo de configuración también debe manejar el evento de cierre para desconectarse cuando el nodo se detiene.

Dependiendo de como esté diseñado un nodo usará un nodo de configuración concreto. Cuando instalamos de la librería un conjunto de nodos vemos los nodos de configuración que también se instalan, p.e. https://flows.nodered.org/node/node-red-dashboard instala 3 nodos de configuración.

La barra lateral de los nodos de configuración proporciona una lista de todos los nodos de configuración, organizados por su alcance. Cada nodo muestra su tipo y etiqueta, junto con un recuento de cuántos nodos de flujo regular utilizan actualmente ese nodo de configuración.

Si el nodo de configuración no se utiliza, se muestra con un contorno de puntos. La vista también se puede filtrar para mostrar solo los nodos no utilizados seleccionando el filtro «no utilizado» en el encabezado.

El cuadro de diálogo de edición de un nodo de configuración se puede abrir haciendo doble clic en el nodo.

Más información: https://nodered.org/docs/creating-nodes/config-nodes 

La información confidencial de los nodos de configuración se guardan en el fichero cifrado flows_cred.json y no se comparte al exportar. El resto de datos de los nodos de configuración usados en el flow exportado, junto con su información, sí se exportan.