Articles Archives - Página 2 De 12

Manejo de Errores de Flogo

2025-11-03 por Alexandre Vazquez

Tabla de contenidos

Introducción
Manejador de Errores
Condición de Error
Actividad de Lanzar Error

Introducción

Hemos cubierto los conceptos básicos del desarrollo de Flogo Enterprise en los artículos anteriores, pero hay un tema importante que no se ha discutido hasta ahora, y este es el manejo de errores de flogo. Siempre pensamos que todo va a funcionar como lo planeamos, y todo va a seguir el camino verde, pero la mayoría de las veces no es así, por lo que necesitas preparar tus flujos para estar listo para manejar estas situaciones.

Si estás acostumbrado al desarrollo de TIBCO BusinessWorks te vas a acostumbrar porque la mayoría de las formas de hacer las cosas son prácticamente las mismas, por lo que cualquier tipo de lógica que apliques a tus desarrollos se puede aplicar aquí. Cubramos primero los conceptos básicos.

Manejador de Errores

Un manejador de errores de flogo es la forma principal en que los desarrolladores de Flogo manejan los problemas que ocurren en el desarrollo y ha sido así para todas las versiones desde la primera hasta Flogo Enterprise 2.6.0 porque hasta ese momento era la única forma de hacerlo.

El manejador de errores es un flujo de errores diferente que se va a invocar cuando algo está mal, similar a un flujo de captura en el desarrollo de TIBCO BusinessWorks. Cuando haces clic en el botón de Manejador de Errores vas a entrar en un nuevo flujo con un iniciador predefinido llamado error como puedes ver en la imagen a continuación:

Los datos que van a iniciar este flujo son el nombre de la actividad que falló y el mensaje de falla, y luego puedes realizar cualquier lógica de manejo que necesites hacer hasta que el flujo sea devuelto. Las actividades que podrías usar y la lógica son exactamente las mismas que puedes usar en tu flujo principal.

Condición de Error

Desde Flogo Enterprise 2.6.0 se ha incluido una nueva forma de manejar errores, como dijimos hasta ese punto cualquier error genera una invocación del manejador de errores, pero esto no cubre todos los escenarios de uso cuando ocurre un error.

Como Flogo Enterprise comienza con un escenario de caso de uso de microservicio simple, el manejo de errores era suficiente para manejarlo, pero ahora, a medida que el poder y las características que Flogo proporciona han ido aumentando, se necesitan nuevos métodos para capturar y actuar cuando ocurre un error para cubrir estos nuevos escenarios. Entonces, ahora cuando creas una condición de rama puedes elegir tres opciones: Éxito, Éxito con Condición y Error.

Para hacer eso, solo necesitas hacer clic en el botón de motor que aparece en la creación de la rama desde la actividad que está generando el error:

Y podrías elegir una de las tres situaciones como puedes ver en la imagen a continuación:

Como las ramas son acumulativas, podemos tener una actividad con diferentes ramas de diferentes tipos:

Pero solo puedes agregar una rama de Tipo de Error para cada actividad, si intentas agregar otro campo se va a deshabilitar, por lo que no podrás hacerlo:

Actividad de Lanzar Error

Todo este contenido se ha centrado en cómo manejar errores cuando ocurren, pero también puedes necesitar lo contrario para poder detectar algo, hacer algunas verificaciones y decidir que esto debería manejarse como un error.

Para hacer eso tienes la Actividad de Lanzar Error donde puedes pasar los datos del error que deseas manejar en una interfaz de elemento de dos claves, una para el mensaje de error y otra para los datos del error, como puedes ver en la imagen a continuación:

Rendimiento de Flogo: ¿Qué tan eficientes pueden ser tus servicios con Flogo? (Flogo vs Python)

2025-11-03 por Alexandre Vazquez

Tabla de contenidos

Introducción
Escenario
Resultados y Conclusiones
Conclusiones
Recursos
- GitHub – alexandrev/flogo-vs-python-medium

Introducción

En publicaciones anteriores, hemos hablado mucho sobre todas las capacidades de Flogo y cómo hacer diferentes tipos de cosas con Flogo, y un mensaje siempre se subrayó allí: rendimiento, rendimiento, rendimiento… pero ¿cómo se compara el rendimiento de Flogo con otros lenguajes de programación modernos?

Para poder compartir algunos datos reales, lo mejor que podemos hacer es realizar nuestra prueba. Para hacer nuestra prueba, vamos a comparar nuestro desarrollo en Flogo frente al mismo usando Python.

Podrías preguntar por qué estamos comparando desarrollos en Flogo y desarrollos en Python y la respuesta es muy simple. Python es ahora uno de los lenguajes más de moda, recientemente agregado como el tercer lenguaje principal en el Índice TIOBE y el lenguaje principal cuando hablamos de scripting de ciencia de datos:

Escenario

Prueba 1

Nos gustaría probar ambas tecnologías, pero también ver cómo se comparan con la nueva realidad para microservicios y poder integrarse con Servicios en la Nube, y creemos que la mejor opción para esta prueba será usar Amazon S3 para poder ver cómo se desempeñan ambas tecnologías.

Entonces, vamos a subir archivos a Amazon S3 y ver cómo se desempeñan ambas tecnologías. Y seleccionamos las siguientes pruebas:

Archivo A: pequeño 138 KB. Número de iteraciones, 1, 10, 50.
Archivo B: mediano 7 MB. Número de iteraciones 1, 10, 50.
Archivo C: grande 50MB. Número de iteraciones 1, 10, 50.

Estamos usando el siguiente script de Python para probar la integración con S3:

import boto3

import time

import sys

import psutil

from botocore.exceptions import NoCredentialsError

ACCESS_KEY = 'XXXXXXXXXXXXXXXXX'

SECRET_KEY = 'XXXXXXXXXXXXXXXXXXXXXXXXXXX'

def upload_to_aws(local_file, bucket, s3_file):

       s3 = boto3.client('s3', aws_access_key_id=ACCESS_KEY,

       aws_secret_access_key=SECRET_KEY)

       try:

           s3.upload_file(local_file, bucket, s3_file)

          print("Subida Exitosa")

          return True

       except FileNotFoundError:

          print("El archivo no fue encontrado")

          return False

       except NoCredentialsError:

          print("Credenciales no disponibles")

          return False

def launch():

    start = time.time()

    for x in range(0, int(sys.argv[1])):

    uploaded = upload_to_aws('D:/Data/Downloads/export.sql', 'testflogovspython', 'export.sql')

    end = time.time()

    print("Tiempo: " +  str(end - start))

launch()

Y vamos a usar la siguiente Aplicación Flogo (varios flujos para cada uno de los casos que nos gustaría verificar)

Prueba 2

Ahora, como esto va a ser para construir microservicios o aplicaciones en un mundo en la nube, veamos cómo se desempeñan ambos al hacer una simple API REST de Hello World. Para la parte de Python vamos a usar Flask para crear el servicio web y el siguiente fragmento:

from flask import Flask

app = Flask(__name__)

@app.route("/")

def hello():

    return "¡Hola Mundo!"

if __name__ == '__main__':

    app.run(debug=True)

NOTA: Mantenemos el debug=True para hacerlo equivalente al nivel de sistema INFO predeterminado en la Aplicación Flogo

Y para Flogo un simple REST Hello World como este:

Resultados y Conclusiones

Prueba 1

Estamos obteniendo los siguientes números como puedes ver en el gráfico a continuación:

Incluso en este ejemplo de código bastante simple, el rendimiento de la aplicación Flogo es demasiado increíble para compararse con otro lenguaje bien ejecutado como Python.

Estamos hablando de un promedio de más del 50% más rápido el desarrollo en Flogo frente al de Python, y aún más cuando el tamaño del archivo es pequeño y lo más importante es cómo el lenguaje y las plataformas están manejando las cosas porque el porcentaje de tiempo respecto al ancho de banda no es lo suficientemente grande como para hacer que todos los valores dependan de la conexión que tengas disponible en ese momento.

Si hablamos sobre el consumo de memoria, los datos son bastante estables para ambos lenguajes, lo cual es una muy buena señal de cómo se maneja la memoria para esas plataformas. Pero en esta batalla también gana Flogo porque si usamos el último, el más grande, Flogo es estable en 22,7 MB frente a 55 MB de Python, también más del 50% mejor una vez más.

Prueba 2

Para los resultados del servicio API REST son bastante similares a los de la primera PRUEBA, y estamos viendo los siguientes resultados respecto a TPS y tiempo de respuesta:

Como podemos ver, en primer lugar, el tiempo de respuesta siempre es menor desde la API de Flogo (y recuerda que esta es una prueba predeterminada, sin ajustes especiales o algo similar) y también el tiempo de respuesta se desempeña mejor en Flogo, siendo capaz de mantenerse estable casi hasta 4 hilos y luego ser capaz de controlar el aumento mientras que el servicio REST de Python después de 2 hilos el tiempo de respuesta aumenta más del doble con cada prueba.

Lo mismo ocurre con respecto a TPS, donde en el caso de Flogo todos los valores son mejores que el anterior. Por supuesto, se alcanza algún tipo de límite en 8 hilos, pero en el caso de Python esta raíz se alcanza en 2 hilos y después de ese punto todos los valores son peores que el anterior.

En cuanto a la memoria, el consumo es bastante similar al de la prueba anterior, ambas soluciones mantienen el uso de memoria bastante bajo y estable. En este caso, Python siempre es estable en 20.3 MB y Flogo comienza en 15 MB pero alcanza su pico en 21.8 y luego vuelve a 18.8 MB. Así que, como dije, son bastante similares en cuanto al uso de memoria en esta prueba.

Conclusiones

Entonces, la conclusión es clara, no importa cuán bien creas que tu lógica se está ejecutando en Python, deberías intentar hacerlo usando Flogo porque, en este tiempo donde cada MB y cada milisegundo cuenta para hacer más pequeña tu factura de Infraestructura, Flogo va a ser tu mejor herramienta para exprimir todo el poder de tu infraestructura.

Recursos

Puedes encontrar todo el código que he usado para estas pruebas en el repositorio de GitHub que se muestra a continuación:

GitHub – alexandrev/flogo-vs-python-medium

Contribuir al desarrollo de alexandrev/flogo-vs-python-medium creando una cuenta en GitHub.

Soporte JWT de Flogo

2025-11-03 por Alexandre Vazquez

Introducción a OAuth 2.0 y JWT

OAuth 2.0

OAuth 2.0 es un protocolo que permite a los usuarios autorizar a terceros a acceder a su información sin necesidad de conocer las credenciales del usuario. Generalmente, se basa en un sistema adicional que actúa como Proveedor de Identidad donde el usuario se va a autenticar, y una vez autenticado se le proporciona una pieza segura de información con los privilegios del usuario y puede usar esa pieza para autenticar sus solicitudes por un período de tiempo.

OAuth 2.0 también define una serie de flujos de concesión para adaptarse a diferentes necesidades de autenticación. Estas concesiones de autorización son las siguientes:

Credenciales del Cliente
Código de Autorización
Credenciales de Contraseña del Propietario del Recurso

La decisión de elegir un flujo u otro depende de las necesidades de la invocación y, por supuesto, es una decisión personal del cliente, pero de manera general, la aproximación mostrada en la documentación de Auth0 es la recomendación habitual:

Estas concesiones se basan en JSON Web Token para transmitir información entre las diferentes partes.

JWT

JSON Web Token es un estándar de la industria para la generación de tokens definido en el estándar RFC 7519. Define una forma segura de enviar información entre partes como un objeto JSON.

Está compuesto por tres componentes (Encabezado, Carga Útil y Firma) y puede ser utilizado por un cifrado simétrico o con un modo de intercambio de clave pública/privada usando RSA o ECDSA.

Escenario de Caso de Uso

Entonces, OAuth V2 y JWT son la forma habitual de autenticar solicitudes en el mundo de los Microservicios, por lo que es importante tener este estándar soportado en tu marco de trabajo, y esto está perfectamente cubierto en Flogo Enterprise como vamos a ver en esta prueba.

Configuración de AWS Cognito

Vamos a usar AWS Cognito como el Servidor de Autorización, ya que es bastante fácil de configurar y es uno de los principales actores en este tipo de autenticación. En palabras de Amazon:

Amazon Cognito te permite agregar registro de usuarios, inicio de sesión y control de acceso a tus aplicaciones web y móviles de manera rápida y sencilla. Amazon Cognito escala a millones de usuarios y admite inicio de sesión con proveedores de identidad social, como Facebook, Google y Amazon, y proveedores de identidad empresarial a través de SAML 2.0.

En nuestro caso, vamos a hacer una configuración bastante sencilla y los pasos a continuación se muestran a continuación:

Crear un Grupo de Usuarios llamado “Flogo”
Crear un Cliente de Aplicación con un secreto generado llamado “TestApplication”
Crear un Servidor de Recursos llamado “Test” con identificador “http://flogo.test1” y con un alcance llamado “echo”

Establecer la siguiente Configuración del Cliente de Aplicación como se muestra en la imagen a continuación con los siguientes detalles:

Grupo de Usuarios de Cognito seleccionado como Proveedor de Identidad Habilitado
Credenciales del cliente utilizadas como Flujos de OAuth Permitidos
http://flogo.test1/echo seleccionado como un alcance habilitado

Y eso es toda la configuración necesaria a nivel de Cognito, y ahora volvamos a la interfaz web de Flogo Enterprise.

Configuración de Flogo

Ahora, vamos a crear un Servicio REST y vamos a omitir todos los pasos sobre cómo crear un servicio REST usando Flogo, pero puedes echar un vistazo a los pasos detallados en el flujo a continuación:

Construyendo tu Primera Aplicación Flogo

En el anterior post, introducimos la tecnología Flogo como una de las cosas en la industria de desarrollo cloud-native y ahora vamos a construir nuestra primera Aplicación Flogo e intentar cubrir todas las opciones que describimos en el anterior post. NOTA .- Si eres nuevo en Flogo y no leíste el anterior post […]

Vamos a crear un servicio de eco alojado en localhost:9999/hello/ que recibe un parámetro de ruta después de hello que es el nombre que nos gustaría saludar, y vamos a establecer las siguientes restricciones:

Vamos a verificar la presencia de un Token JWT
Vamos a validar el Token JWT
Vamos a verificar que el JWT incluya el http://flogo.test1/echo

En caso de que todo esté bien, vamos a ejecutar el servicio, en caso de que no se cumpla algún requisito previo, vamos a devolver un error 401 No Autorizado.

Vamos a crear dos flujos:

Flujo principal que va a tener el Servicio REST
Subflujo para realizar todas las validaciones relacionadas con JWT.

El flujo principal es bastante sencillo, va a recibir la solicitud, ejecutar el subflujo y dependiendo de su salida va a ejecutar el servicio o no:

Entonces, toda la lógica importante está dentro del otro flujo que va a realizar toda la Validación JWT, y su estructura es la que se muestra a continuación:

Vamos a usar la actividad JWT alojada en GitHub disponible en el enlace que se muestra a continuación:

flogo-components/activity/jwt at master · ayh20/flogo-components

Contribute to ayh20/flogo-components development by creating an account on GitHub.

NOTA: Si no recuerdas cómo instalar una extensión de Flogo Enterprise, echa un vistazo al enlace a continuación:

Instalando Extensiones en Flogo Enterprise

En posts anteriores, hemos hablado sobre las capacidades de Flogo y cómo construir nuestra primera aplicación Flogo, así que en este momento si has leído ambos, tienes un conocimiento claro sobre lo que Flogo proporciona y lo fácil que es crear aplicaciones en Flogo. Pero en esas capacidades, hemos hablado sobre que una de […]

Y después de eso, la configuración es bastante fácil, ya que la actividad te permite elegir la acción que deseas realizar con el token. En nuestro caso, “Verificar” y proporcionamos el token, el algoritmo (en nuestro caso “RS256”) y la clave pública que vamos a usar para validar la firma del token:

Prueba

Ahora, vamos a lanzar la Aplicación Flogo Enterprise desde el binario generado:

Y ahora, si intentamos hacer una ejecución al endpoint sin proporcionar ningún token obtenemos el código de respuesta 401 esperado

Entonces, para obtener el token de acceso, lo primero que necesitamos hacer es enviar una solicitud al endpoint de AWS Cognito (https://flogotest.auth.eu-west-2.amazoncognito.com/oauth2/token) usando nuestras credenciales de aplicación:

Y este token tiene toda la información del cliente y sus permisos, puedes verificarlo en la página web jwt.io:

Y para finalmente probarlo, solo necesitamos agregarlo a la primera solicitud que intentamos como podemos ver en la imagen a continuación:

Recursos

GitHub – alexandrev/flogo-jwt-sample-medium: Soporte JWT en Flogo Enterprise Post Resource

Soporte JWT en Flogo Enterprise Post Resource. Contribuye al desarrollo de alexandrev/flogo-jwt-sample-medium creando una cuenta en GitHub.

Prueba de Flogo: ¡Aprende a Dominar las Pruebas en Flogo!

2025-11-03 por Alexandre Vazquez

Prueba Flogo: ¡Aprende Cómo Dominar Pruebas en Flogo! — Foto de David Travis en Unsplash

La Prueba Flogo es uno de los pasos principales en tu ciclo de vida CI/CD si estás usando Flogo. Probablemente lo has hecho anteriormente en todos tus otros desarrollos como desarrollos en Java o incluso usando BusinessWorks 6 usando el bw6-maven-plugin:

GitHub – TIBCOSoftware/bw6-plugin-maven: Código del Plug-in para Apache Maven y TIBCO ActiveMatrix BusinessWorks™

Código del Plug-in para Apache Maven y TIBCO ActiveMatrix BusinessWorks™ – GitHub – TIBCOSoftware/bw6-plugin-maven: Código del Plug-in para Apache Maven y TIBCO ActiveMatrix BusinessWorks™

Entonces, probablemente te estés preguntando… ¿Cómo se va a hacer esto con Flogo? ¡Ok! Te lo diré.

Primero que nada, necesitas tener en cuenta que Flogo Enterprise es un producto que fue diseñado con todos esos aspectos en mente, así que no necesitas preocuparte por ello.

En cuanto a las pruebas, cuando necesitamos incluirlas dentro de un enfoque de ciclo de vida CI/CD, estas capacidades de prueba deben cumplir con los siguientes requisitos:

Debe estar definido en algunos artefactos.
Debe ejecutarse automáticamente
Debe ser capaz de verificar el resultado.

Flogo Enterprise incluye por defecto capacidades de Prueba en la interfaz web donde no solo puedes probar tus flujos usando la interfaz desde una perspectiva de depuración/solución de problemas, sino que también puedes generar los artefactos que te permitirán realizar pruebas más sofisticadas

Entonces, necesitamos ir a nuestra interfaz web y cuando estemos dentro de un flujo tenemos un botón de “Iniciar Pruebas”:

Y podemos ver toda nuestra Configuración de Lanzamiento cambiar y la parte más importante para este tema es poder exportarla y descargarla a tu máquina local:

Una vez que todo está descargado y tenemos el binario para nuestra aplicación, podemos ejecutar las pruebas de manera automática desde la CLI usando el siguiente comando

.FlogoJWTEcho-windows_amd64.exe' -test -flowin .MainFlow_Launch_Configuration_1.json -flowout MainFlow_out.json

Esto va a generar un archivo de salida con el resultado de la prueba de ejecución:

Y si abrimos el archivo obtendremos exactamente el mismo resultado que el flujo devuelve para que podamos realizar cualquier aserción sobre él

Eso fue fácil, ¿verdad? Hagamos algunos ajustes adicionales para evitar que necesites ir a la interfaz web. Puedes generar la configuración de lanzamiento usando solo la CLI.

Para hacer eso, solo necesitas ejecutar el siguiente comando:

.FlogoJWTEcho-windows_amd64.exe' -test -flowdata MainFlow

Pero, ¿cómo sabes los flujos en tu aplicación sin ir a la interfaz web de Flogo? Solo con el siguiente comando:

.FlogoJWTEcho-windows_amd64.exe' -test  -flows

Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!

2025-11-03 por Alexandre Vazquez

Prometheus se está convirtiendo en el nuevo estándar para la monitorización de Kubernetes y hoy vamos a cubrir cómo podemos hacer la monitorización de Prometheus TIBCO en Kubernetes.

Estamos viviendo en un mundo con cambios constantes y esto es aún más cierto en el mundo de las Aplicaciones Empresariales. No pasaré mucho tiempo hablando de cosas que ya conoces, pero solo diré que el enfoque de arquitectura de microservicios y las soluciones PaaS han sido un cambio de juego para todas las tecnologías de integración empresarial.

Esta vez me gustaría hablar sobre la monitorización y las capacidades de integración que tenemos al usar Prometheus para monitorear nuestros microservicios desarrollados bajo la tecnología TIBCO. Tampoco me gusta pasar demasiado tiempo hablando sobre qué es Prometheus, ya que probablemente ya lo sepas, pero en resumen, esta es una plataforma de monitorización distribuida de código abierto que ha sido el segundo proyecto lanzado por la Cloud Native Computing Foundation (después de Kubernetes en sí) y que se ha establecido como un estándar de facto de la industria para la monitorización de clústeres K8S (junto con otras opciones en el mercado como InfluxDB, etc.).

Prometheus tiene muchas características excelentes, pero una de ellas es que tiene conectores para casi todo y eso es muy importante hoy en día porque es tan complicado/no deseado/inusual definir una plataforma con un solo producto para la capa PaaS. Así que hoy, quiero mostrarte cómo monitorear tus aplicaciones de TIBCO BusinessWorks Container Edition usando Prometheus.

La mayor parte de la información que voy a compartir está disponible en el repositorio de GitHub bw-tooling, por lo que puedes ir allí si necesitas validar alguna declaración específica.

bw-tooling/prometheus-integration at master · TIBCOSoftware/bw-tooling

Colección de herramientas diseñadas para simplificar el despliegue y la gestión de aplicaciones TIBCO BusinessWorks – bw-tooling/prometheus-integration at master · TIBCOSoftware/bw-tooling

¿Ok, estamos listos? ¡¡Empecemos!!

Voy a asumir que ya tenemos un clúster de Kubernetes en su lugar y Prometheus instalado también. Entonces, el primer paso es mejorar la imagen base de BusinessWorks Container Edition para incluir la integración de capacidades de Prometheus. Para hacer eso, necesitamos ir a la página del repositorio de GitHub y seguir estas instrucciones:

Descargar y descomprimir la carpeta prometheus-integration.zip.

Monitorización de Prometheus TIBCO para Contenedores

Abrir TIBCO BusinessWorks Studio y apuntarlo a un nuevo espacio de trabajo.
Hacer clic derecho en Project Explorer → Importar… → seleccionar Plug-ins y Fragmentos → seleccionar el botón de radio Importar desde el directorio

Navegar a la carpeta prometheus-integration (descomprimida en el paso 1)

Ahora hacer clic en Siguiente → Seleccionar el plugin de Prometheus → hacer clic en el botón Agregar → hacer clic en Finalizar. Esto importará el plugin en el estudio.

Ahora, para crear el JAR de este plugin, primero necesitamos asegurarnos de actualizar com.tibco.bw.prometheus.monitor con ‘.’ (punto) en el campo Bundle-Classpath como se indica a continuación en el archivo META-INF/MANIFEST.MF.

Hacer clic derecho en Plugin → Exportar → Exportar…

Seleccionar tipo como archivo JAR y hacer clic en Siguiente

Ahora hacer clic en Siguiente → Siguiente → seleccionar el botón de radio para usar el archivo MANIFEST.MF existente y buscar el archivo manifest

Hacer clic en Finalizar. Esto generará prometheus-integration.jar

Ahora, con el JAR ya creado, lo que necesitamos hacer es incluirlo en tu propia imagen base. Para hacer eso, colocamos el archivo JAR en <TIBCO_HOME>/bwce/2.4/docker/resources/addons/jar

Y lanzamos el comando de construcción de imagen nuevamente desde la carpeta <TIBCO_HOME>/bwce/2.4/docker para actualizar la imagen usando el siguiente comando (usa la versión que estés usando en el momento)

docker build -t bwce_base:2.4.4 .

Entonces, ahora tenemos una imagen con soporte para Prometheus! ¡Genial! Estamos cerca del final, solo creamos una imagen para nuestra Aplicación de Contenedor, en mi caso, esto va a ser un servicio de eco muy simple que puedes ver aquí.

Y solo necesitamos mantener estas cosas en particular cuando desplegamos en nuestro clúster de Kubernetes:

Debemos establecer una variable de entorno con BW_PROMETHEUS_ENABLE en “TRUE”
Debemos exponer el puerto 9095 desde el contenedor para ser usado por Prometheus para integrar.

Ahora, solo necesitamos proporcionar este endpoint al sistema de scrapper de Prometheus. Hay varias maneras de hacer eso, pero nos vamos a centrar en la más simple.

Necesitamos cambiar el prometheus.yml para agregar los siguientes datos del trabajo:

- job_name: 'bwdockermonitoring'
  honor_labels: true
  static_configs:
    - targets: ['phenix-test-project-svc.default.svc.cluster.local:9095']
      labels:
        group: 'prod'

Y después de reiniciar Prometheus, tenemos todos los datos indexados en la base de datos de Prometheus para ser usados en cualquier sistema de panel de control.

En este caso, voy a usar Grafana para hacer un panel de control rápido.

Cada uno de estos componentes de gráfico está configurado en base a las métricas que están siendo extraídas por el exportador de Prometheus TIBCO.

Configuración de Flogo: ¿Cómo dominarla en 5 minutos?

2025-11-03 por Alexandre Vazquez

Flogo Enterprise es una plataforma excelente para construir tus microservicios y, desde el principio, vas a alcanzar un número de rendimiento increíble.

Pero, incluso con eso, estamos trabajando en un mundo donde cada milisegundo cuenta y cada MB de memoria cuenta, por lo que es importante conocer las herramientas que tenemos en nuestras manos para ajustar a un nivel más fino nuestra aplicación Flogo Enterprise.

Como ya sabes, Flogo está construido sobre el lenguaje de programación Go, por lo que vamos a diferenciar los parámetros que pertenecen al propio lenguaje de programación, y luego otros parámetros que son específicos de Flogo.

Todos estos parámetros deben definirse como variables de entorno, por lo que la forma de aplicarlos dependerá de cómo configures las variables de entorno en tu propia plataforma de destino (Windows, Linux, OSX, Docker, etc…)

Parámetros Específicos de Flogo OSS

Puedes consultar todos los parámetros y sus valores predeterminados en la documentación de Flogo:

Configuraciones Relacionadas con el Rendimiento

FLOGO_LOG_LEVEL: Permite establecer a nivel de inicio el nivel de registro que deseas usar para la ejecución de la aplicación. El valor predeterminado está configurado en «INFO» y se puede aumentar a DEBUG para realizar algunos diagnósticos o análisis adicionales y configurar en «WARN» o «ERROR» para aplicaciones de producción que necesitan el máximo rendimiento evitando imprimir trazas adicionales.
FLOGO_RUNNER_TYPE: Permite establecer a nivel de inicio el tipo de corredor y el valor predeterminado es POOLED.
FLOGO_RUNNER_WORKERS: Permite establecer a nivel de inicio el número de trabajadores de Flogo que van a ejecutar la lógica. El valor predeterminado es 5 y se puede aumentar cuando estás ejecutando en hardware potente que tiene mejores capacidades de paralelismo.
FLOGO_RUNNER_QUEUE: Permite configurar a nivel de inicio el tamaño de la cola del corredor que va a mantener en memoria las solicitudes que van a ser manejadas por los trabajadores. El valor predeterminado es 50 y cuando el número es alto también será alto el consumo de memoria, pero el acceso de los trabajadores a la tarea será más rápido.

Otras Configuraciones

FLOGO_CONFIG_PATH: Establece la ruta del archivo JSON de configuración que se va a usar para ejecutar la aplicación en caso de que no esté incrustado en el propio binario. El valor predeterminado es flogo.json
FLOGO_ENGINE_STOP_ON_ERROR: Establece el comportamiento del motor cuando ocurre un error interno. Por defecto está configurado en true y significa que el motor se detendrá tan pronto como ocurra el error.
FLOGO_APP_PROP_RESOLVERS: Establece cómo se van a recopilar las propiedades de la aplicación para ser utilizadas. El valor es el resolvedor de propiedades a usar en tiempo de ejecución. Por defecto es None y se incluye información adicional en la sección de documentación de propiedades de la aplicación.
FLOGO_LOG_DTFORMAT: Establece cómo se van a mostrar las fechas en las trazas de registro. El valor predeterminado es «2006–01–02 15:04:05.000».

Parámetros Específicos de Flogo Enterprise

Incluso cuando todas las propiedades de Project Flogo son compatibles con Flogo Enterprise, la versión empresarial incluye propiedades adicionales que se pueden usar para establecer comportamientos adicionales del motor.

FLOGO_HTTP_SERVICE_PORT: Esta propiedad establece el puerto donde se alojarán los puntos finales internos. Este punto final interno se utiliza para el punto final de verificación de estado, así como para la exposición de métricas y cualquier otro acceso interno que proporcione el motor.

FLOGO_LOG_FORMAT: Esta propiedad nos permite definir el formato de notación para nuestras trazas de registro. TEXT es el valor predeterminado, pero podemos usar JSON para que nuestras trazas se generen en JSON, por ejemplo, para ser incluidas en algún tipo de plataforma de ingestión de registros.

Parámetros Específicos del Lenguaje de Programación Go

GOMAXPROCS: Limita el número de hilos del sistema operativo que pueden ejecutar código Go a nivel de usuario simultáneamente. No hay límite para el número de hilos que pueden estar bloqueados en llamadas al sistema en nombre del código Go; esos no cuentan contra el límite de GOMAXPROCS.
GOTRACEBACK: Controla la cantidad de salida generada cuando un programa Go falla debido a un pánico no recuperado o una condición de tiempo de ejecución inesperada. Por defecto, un fallo imprime una traza de pila para la goroutine actual, omitiendo funciones internas del sistema de tiempo de ejecución y luego sale con el código de salida 2. El fallo imprime trazas de pila para todas las goroutines si no hay una goroutine actual o el fallo es interno al tiempo de ejecución. GOTRACEBACK=none omite completamente las trazas de pila de goroutine. GOTRACEBACK=single (el valor predeterminado) se comporta como se describe arriba. GOTRACEBACK=all agrega trazas de pila para todas las goroutines creadas por el usuario. GOTRACEBACK=system es como «all» pero agrega marcos de pila para funciones de tiempo de ejecución y muestra goroutines creadas internamente por el tiempo de ejecución. GOTRACEBACK=crash es como «system» pero falla de una manera específica del sistema operativo en lugar de salir.
GOGC: Establece el porcentaje objetivo inicial de recolección de basura. Se activa una recolección cuando la proporción de datos recién asignados a datos vivos restantes después de la recolección anterior alcanza este porcentaje. El valor predeterminado es GOGC=100. Configurar GOGC=off desactiva completamente el recolector de basura.

Descubrimiento de servicios de Kubernetes para Prometheus

2025-11-03 por Alexandre Vazquez

En publicaciones anteriores, describimos cómo configurar Prometheus para trabajar con tus aplicaciones de TIBCO BusinessWorks Container Edition, y puedes leer más al respecto aquí.

[visual-link-preview encoded=»eyJ0eXBlIjoiaW50ZXJuYWwiLCJwb3N0IjoxMTEsInBvc3RfbGFiZWwiOiJQb3N0IDExMSAtIFByb21ldGhldXMgTW9uaXRvcmluZyBmb3IgTWljcm9zZXJ2aWNlcyB1c2luZyBUSUJDTyIsInVybCI6IiIsImltYWdlX2lkIjoyNjI4LCJpbWFnZV91cmwiOiJodHRwOi8vYWxleGFuZHJlLXZhenF1ZXouY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzAxLzEtNmIyS25hQWNtME9TSVpySFJwcFRnLnBuZyIsInRpdGxlIjoiUHJvbWV0aGV1cyBNb25pdG9yaW5nIGZvciBNaWNyb3NlcnZpY2VzIHVzaW5nIFRJQkNPIiwic3VtbWFyeSI6Ildl4oCZcmUgbGl2aW5nIGEgd29ybGQgd2l0aCBjb25zdGFudCBjaGFuZ2VzIGFuZCB0aGlzIGlzIGV2ZW4gbW9yZSB0cnVlIGluIHRoZSBFbnRlcnByaXNlIEFwcGxpY2F0aW9uIHdvcmxkLiBJ4oCZbGwgbm90IHNwZW5kIG11Y2ggdGltZSB0YWxraW5nIGFib3V0IHRoaW5ncyB5b3UgYWxyZWFkeSBrbm93LCBidXQganVzdCBzYXkgdGhhdCB0aGUgbWljcm9zZXJ2aWNlcyBhcmNoaXRlY3R1cmUgYXBwcm9hY2ggYW5kIHRoZSBQYWFTIHNvbHV0aW9ucyBoYXZlIGJlZW4gYSBnYW1lLWNoYW5nZXIgZm9yIGFsbCBlbnRlcnByaXNlIGludGVncmF0aW9uIHRlY2hub2xvZ2llcy4gVGhpcyB0aW1lIEnigJlkIGxpa2UgdG8gWyZoZWxsaXA7XSIsInRlbXBsYXRlIjoidXNlX2RlZmF1bHRfZnJvbV9zZXR0aW5ncyJ9″]

En esa publicación, describimos que había varias formas de actualizar a Prometheus sobre los servicios que están listos para monitorear. Y elegimos la más simple en ese momento que era la configuración de static_config, lo que significa:

No te preocupes Prometheus, te haré saber la IP que necesitas monitorear y no necesitas preocuparte por nada más.

Y esto es útil para una prueba rápida en un entorno local cuando quieres probar rápidamente tu configuración de Prometheus o quieres trabajar en la parte de Grafana para diseñar el mejor tablero posible para manejar tus necesidades.

Pero, esto no es muy útil para un entorno de producción real, aún más, cuando estamos hablando de un clúster de Kubernetes donde los servicios están subiendo y bajando continuamente con el tiempo. Entonces, para resolver esta situación, Prometheus nos permite definir diferentes tipos de formas para realizar este enfoque de «descubrimiento de servicios». En la documentación oficial de Prometheus, podemos leer mucho sobre las diferentes técnicas de descubrimiento de servicios, pero a un nivel alto, estas son las principales técnicas de descubrimiento de servicios disponibles:

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9wcm9tZXRoZXVzLmlvL2RvY3MvcHJvbWV0aGV1cy9sYXRlc3QvY29uZmlndXJhdGlvbi9jb25maWd1cmF0aW9uLyIsImltYWdlX2lkIjotMSwiaW1hZ2VfdXJsIjoiaHR0cHM6Ly9wcm9tZXRoZXVzLmlvL2Fzc2V0cy9mYXZpY29ucy9hbmRyb2lkLWNocm9tZS0xOTJ4MTkyLnBuZyIsInRpdGxlIjoiQ29uZmlndXJhdGlvbiB8IFByb21ldGhldXMiLCJzdW1tYXJ5IjoiQW4gb3Blbi1zb3VyY2UgbW9uaXRvcmluZyBzeXN0ZW0gd2l0aCBhIGRpbWVuc2lvbmFsIGRhdGEgbW9kZWwsIGZsZXhpYmxlIHF1ZXJ5IGxhbmd1YWdlLCBlZmZpY2llbnQgdGltZSBzZXJpZXMgZGF0YWJhc2UgYW5kIG1vZGVybiBhbGVydGluZyBhcHByb2FjaC4iLCJ0ZW1wbGF0ZSI6InVzZV9kZWZhdWx0X2Zyb21fc2V0dGluZ3MifQ==»]

azure_sd_configs: Descubrimiento de Servicios de Azure
consul_sd_configs: Descubrimiento de Servicios de Consul
dns_sd_configs: Descubrimiento de Servicios de DNS
ec2_sd_configs: Descubrimiento de Servicios de EC2
openstack_sd_configs: Descubrimiento de Servicios de OpenStack
file_sd_configs: Descubrimiento de Servicios de Archivo
gce_sd_configs: Descubrimiento de Servicios de GCE
kubernetes_sd_configs: Descubrimiento de Servicios de Kubernetes
marathon_sd_configs: Descubrimiento de Servicios de Marathon
nerve_sd_configs: Descubrimiento de Servicios de Nerve de AirBnB
serverset_sd_configs: Descubrimiento de Servicios de Serverset de Zookeeper
triton_sd_configs: Descubrimiento de Servicios de Triton
static_config: IP/DNS Estático para la configuración. Sin Descubrimiento de Servicios.

E incluso, si todas estas opciones no son suficientes para ti y necesitas algo más específico, tienes una API disponible para extender las capacidades de Prometheus y crear tu propia técnica de Descubrimiento de Servicios. Puedes encontrar más información al respecto aquí:

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9wcm9tZXRoZXVzLmlvL2Jsb2cvMjAxOC8wNy8wNS9pbXBsZW1lbnRpbmctY3VzdG9tLXNkLyIsImltYWdlX2lkIjotMSwiaW1hZ2VfdXJsIjoiaHR0cHM6Ly9wcm9tZXRoZXVzLmlvL2Fzc2V0cy9mYXZpY29ucy9hbmRyb2lkLWNocm9tZS0xOTJ4MTkyLnBuZyIsInRpdGxlIjoiSW1wbGVtZW50aW5nIEN1c3RvbSBTZXJ2aWNlIERpc2NvdmVyeSB8IFByb21ldGhldXMiLCJzdW1tYXJ5IjoiQW4gb3Blbi1zb3VyY2UgbW9uaXRvcmluZyBzeXN0ZW0gd2l0aCBhIGRpbWVuc2lvbmFsIGRhdGEgbW9kZWwsIGZsZXhpYmxlIHF1ZXJ5IGxhbmd1YWdlLCBlZmZpY2llbnQgdGltZSBzZXJpZXMgZGF0YWJhc2UgYW5kIG1vZGVybiBhbGVydGluZyBhcHByb2FjaC4iLCJ0ZW1wbGF0ZSI6InVzZV9kZWZhdWx0X2Zyb21fc2V0dGluZ3MifQ==»]

Pero este no es nuestro caso, para nosotros, el Descubrimiento de Servicios de Kubernetes es la elección correcta para nuestro enfoque. Así que, vamos a cambiar la configuración estática que teníamos en la publicación anterior:

- job_name: 'bwdockermonitoring'
  honor_labels: true
  static_configs:
    - targets: ['phenix-test-project-svc.default.svc.cluster.local:9095']
      labels:
        group: 'prod'

Por esta configuración de Kubernetes

- job_name: 'bwce-metrics'
  scrape_interval: 5s
  metrics_path: /metrics/
  scheme: http
  kubernetes_sd_configs:
  - role: endpoints
    namespaces:
      names:
      - default
  relabel_configs:
  - source_labels: [__meta_kubernetes_service_label_app]
    separator: ;
    regex: (.*)
    replacement: $1
    action: keep
  - source_labels: [__meta_kubernetes_endpoint_port_name]
    separator: ;
    regex: prom
    replacement: $1
    action: keep
  - source_labels: [__meta_kubernetes_namespace]
    separator: ;
    regex: (.*)
    target_label: namespace
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_pod_name]
    separator: ;
    regex: (.*)
    target_label: pod
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_service_name]
    separator: ;
    regex: (.*)
    target_label: service
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_service_name]
    separator: ;
    regex: (.*)
    target_label: job
    replacement: 1
    action: replace
  - separator: ;
    regex: (.*)
    target_label: endpoint
    replacement: $1
    action: replace

Como puedes ver, esto es bastante más complejo que la configuración anterior, pero no es tan complejo como podrías pensar a primera vista, revisémoslo por diferentes partes.

- role: endpoints
    namespaces:
      names:
      - default

Dice que vamos a usar el rol para los endpoints que se crean bajo el namespace por defecto y vamos a especificar los cambios que necesitamos hacer para encontrar los endpoints de métricas para Prometheus.

scrape_interval: 5s
 metrics_path: /metrics/
 scheme: http

Esto dice que vamos a ejecutar el proceso de scrape en un intervalo de 5 segundos, usando http en la ruta /metrics/

Y luego, tenemos una sección de relabel_config:

- source_labels: [__meta_kubernetes_service_label_app]
    separator: ;
    regex: (.*)
    replacement: $1
    action: keep
  - source_labels: [__meta_kubernetes_endpoint_port_name]
    separator: ;
    regex: prom
    replacement: $1
    action: keep

Eso significa que nos gustaría mantener esa etiqueta para prometheus:

- source_labels: [__meta_kubernetes_namespace]
    separator: ;
    regex: (.*)
    target_label: namespace
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_pod_name]
    separator: ;
    regex: (.*)
    target_label: pod
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_service_name]
    separator: ;
    regex: (.*)
    target_label: service
    replacement: $1
    action: replace
  - source_labels: [__meta_kubernetes_service_name]
    separator: ;
    regex: (.*)
    target_label: job
    replacement: 1
    action: replace
  - separator: ;
    regex: (.*)
    target_label: endpoint
    replacement: $1
    action: replace

Eso significa que queremos hacer un reemplazo del valor de la etiqueta y podemos hacer varias cosas:

Renombrar el nombre de la etiqueta usando el target_label para establecer el nombre de la etiqueta final que vamos a crear basado en las source_labels.
Reemplazar el valor usando el parámetro regex para definir la expresión regular para el valor original y el parámetro replacement que va a expresar los cambios que queremos hacer a este valor.

Así que, ahora después de aplicar esta configuración cuando despleguemos una nueva aplicación en nuestro clúster de Kubernetes, como el proyecto que podemos ver aquí:

Automáticamente vamos a ver un objetivo adicional en nuestra configuración de job-name “bwce-metrics”

Usar estadísticas a tu favor para detectar cuellos de botella en TIBCO BusinessWorks Container Edition

2025-11-03 por Alexandre Vazquez

Generalmente, cuando estás desarrollando o ejecutando tu aplicación de contenedores, llegarás a un momento en que algo sale mal. Pero no de una manera que puedas resolver con tu sistema de registro y con pruebas.

Un momento en el que hay algún cuello de botella, algo que no está funcionando tan bien como deseas, y te gustaría echar un vistazo adentro. Y eso es lo que vamos a hacer. Vamos a mirar adentro.

Porque nuestra BusinessWorks Container Edition proporciona características tan buenas para hacerlo que necesitas usarlo a tu favor porque me lo vas a agradecer por el resto de tu vida. Así que no quiero pasar un minuto más en esto. Me gustaría comenzar a contarte ahora mismo.

Lo primero que necesitamos hacer es entrar en la consola OSGi desde el contenedor. Entonces, lo primero que hacemos es exponer el puerto 8090 como puedes ver en la imagen a continuación

Ahora, podemos exponer ese puerto a tu host, usando el comando port-forward

kubectl port-forward deploy/phenix-test-project-v1 8090:8090

Y luego podemos ejecutar una solicitud HTTP para ejecutar cualquier información usando comandos como este:

curl -v http://localhost:8090/bw/framework.json/osgi?command=<command>

Y vamos a ejecutar primero la activación de las estadísticas del proceso así:

curl -v http://localhost:8090/bw/framework.json/osgi?command=startpsc

Y como puedes ver, dice que las estadísticas han sido habilitadas para la aplicación echo, así que usando ese nombre de aplicación vamos a recopilar las estadísticas a nivel

curl -v http://localhost:8090/bw/framework.json/osgi?command=lpis%20echo

Y puedes ver las estadísticas a nivel de proceso donde puedes ver las siguientes métricas:

Metadatos del proceso (nombre, proceso padre y versión)
Total de instancias por estado (creado, suspendido, fallido y ejecutado)
Tiempo de ejecución (total, promedio, mínimo, máximo, más reciente)
Tiempo transcurrido (total, promedio, mínimo, máximo, más reciente)

Y podemos obtener las estadísticas a nivel de actividad:

Y con eso, puedes detectar cualquier cuello de botella que estés enfrentando en tu aplicación y también estar seguro de qué actividad o qué proceso es responsable de ello. Así que puedes resolverlo de una manera rápida.

¡Diviértete y usa las herramientas a tu disposición!

Desplegando la aplicación Flogo en OpenFaaS

2025-11-03 por Alexandre Vazquez

OpenFaaS es una alternativa para habilitar el enfoque sin servidor en tu infraestructura cuando no estás operando en la nube pública y no tienes disponibles esas otras opciones como AWS Lambda Functions o Azure Functions, o incluso en la nube pública, te gustaría las características y opciones de personalización que proporciona.

OpenFaaS® (Funciones como Servicio) es un marco para construir funciones sin servidor con Docker y Kubernetes que tiene soporte de primera clase para métricas. Cualquier proceso puede ser empaquetado como una función, permitiéndote consumir una variedad de eventos web sin codificación repetitiva de plantilla.

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9naXRodWIuY29tL29wZW5mYWFzL2ZhYXMiLCJpbWFnZV9pZCI6LTEsImltYWdlX3VybCI6Imh0dHBzOi8vb3BlbmdyYXBoLmdpdGh1YmFzc2V0cy5jb20vOWQzNTgwNDQyZjhlODA2ZjdiYTAwZmVlZDg3ZDRkNWY3ODY2OWZjMzZjY2IwMjVhODhlMDNmYTZiY2RlODNmNi9vcGVuZmFhcy9mYWFzIiwidGl0bGUiOiJHaXRIdWIgLSBvcGVuZmFhcy9mYWFzOiBPcGVuRmFhUyAtIFNlcnZlcmxlc3MgRnVuY3Rpb25zIE1hZGUgU2ltcGxlIiwic3VtbWFyeSI6Ik9wZW5GYWFTIC0gU2VydmVybGVzcyBGdW5jdGlvbnMgTWFkZSBTaW1wbGUuIENvbnRyaWJ1dGUgdG8gb3BlbmZhYXMvZmFhcyBkZXZlbG9wbWVudCBieSBjcmVhdGluZyBhbiBhY2NvdW50IG9uIEdpdEh1Yi4iLCJ0ZW1wbGF0ZSI6InVzZV9kZWZhdWx0X2Zyb21fc2V0dGluZ3MifQ==»]

Hay buen contenido en Medium sobre OpenFaaS, así que no me gusta pasar mucho tiempo en esto, pero me gustaría dejarte aquí algunos enlaces como referencia:

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9zaGFsaXRoYXN1cmFuZ2EubWVkaXVtLmNvbS9ydW5uaW5nLXNlcnZlcmxlc3MtZnVuY3Rpb25zLW9uLXByZW1pc2VzLXVzaW5nLW9wZW5mYWFzLXdpdGgta3ViZXJuZXRlcy02YzdhNjVhZWRiNWIiLCJpbWFnZV9pZCI6LTEsImltYWdlX3VybCI6Imh0dHBzOi8vbWlyby5tZWRpdW0uY29tL21heC8xMjAwLzAqUFlnTUltMm1fQnJLbUd5VCIsInRpdGxlIjoiUnVubmluZyBzZXJ2ZXJsZXNzIGZ1bmN0aW9ucyBvbiBwcmVtaXNlcyB1c2luZyBPcGVuRmFhcyB3aXRoIEt1YmVybmV0ZXMiLCJzdW1tYXJ5IjoiRWFybGllciBtb3N0IG9mIGNvbXBhbmllcyBoYWQgbW9ub2xpdGhpYyBhcmNoaXRlY3R1cmUgZm9yIHRoZWlyIGNsb3VkIGFwcGxpY2F0aW9ucyAoYWxsIHRoZSB0aGluZ3MgaW4gYSBzaW5nbGUgcGFja2FnZSkuIE5vd2FkYXlzIGNvbXBhbmllc+KApiIsInRlbXBsYXRlIjoidXNlX2RlZmF1bHRfZnJvbV9zZXR0aW5ncyJ9″]

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9oYWNrZXJub29uLmNvbS9hbi1pbnRyb2R1Y3Rpb24tdG8tc2VydmVybGVzcy1kZXZvcHMtd2l0aC1vcGVuZmFhcy1iOTc4YWIwZWIyYiIsImltYWdlX2lkIjotMSwiaW1hZ2VfdXJsIjoiaHR0cHM6Ly9jZG4uaGFja2Vybm9vbi5jb20vaG4taW1hZ2VzLzEqZEczQnZqU0gwYmFWUXVPV2JHR0hPZy5wbmciLCJ0aXRsZSI6IkFuIEludHJvZHVjdGlvbiB0byBTZXJ2ZXJsZXNzIERldk9wcyB3aXRoIE9wZW5GYWFTIHwgSGFja2VyTm9vbiIsInN1bW1hcnkiOiJEZXZPcHMgaXNu4oCZdCBhYm91dCBqdXN0IGRvaW5nIENJL0NELiBCdXQgYSBDSS9DRCBwaXBlbGluZSBoYXMgYW4gaW1wb3J0YW50IHJvbGUgaW5zaWRlIERldk9wcy4gSeKAmXZlIGJlZW4gaW52ZXN0aW5nIG15IHRpbWUgb24gcmVjZW50bHkgYW5kIGFzIEkgc3RhcnRlZCBjcmVhdGluZyBtdWx0aXBsZSBmdW5jdGlvbnMsIEkgd2FudGVkIGFuIGVhc3kgdG8gdXNlIGFuZCBhY2Nlc3NpYmxlIGRldmVsb3BtZW50IGFuZCBkZWxpdmVyeSBmbG93LCBpbiBvdGhlciB3b3JkcyBhIENJL0NEIHBpcGVsaW5lLiBPcGVuRmFhUyBPbmUgZGF54oCmIiwidGVtcGxhdGUiOiJ1c2VfZGVmYXVsdF9mcm9tX3NldHRpbmdzIn0=»]

Ya tenemos mucha información sobre cómo ejecutar una aplicación Flogo como una función Lambda, como puedes ver aquí:

https://www.youtube.com/watch?v=TysuwbXODQI

Pero… ¿qué pasa con OpenFaaS? ¿Podemos ejecutar nuestra aplicación Flogo dentro de OpenFaaS? ¡Claro! Déjame explicarte cómo.

OpenFaaS es un marco muy personalizable para construir funciones de escala cero y podría necesitar algo de tiempo para familiarizarse con los conceptos. Todo se basa en watchdogs que son los componentes que escuchan las solicitudes y son responsables de lanzar los forks para manejar las solicitudes:

Vamos a usar el nuevo watchdog llamado of-watchdog que se espera sea el predeterminado en el futuro y toda la información está aquí:

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9naXRodWIuY29tL29wZW5mYWFzL29mLXdhdGNoZG9nIiwiaW1hZ2VfaWQiOi0xLCJpbWFnZV91cmwiOiJodHRwczovL29wZW5ncmFwaC5naXRodWJhc3NldHMuY29tLzcyZjgyODQxNWI1ZjVlYjJkMDY2ODRjMjIwMDNhYWZiMDliMDFjNjE2OWFhODMxOTJiOGFmZTljZjQzNThjNmMvb3BlbmZhYXMvb2Ytd2F0Y2hkb2ciLCJ0aXRsZSI6IkdpdEh1YiAtIG9wZW5mYWFzL29mLXdhdGNoZG9nOiBSZXZlcnNlIHByb3h5IGZvciBTVERJTyBhbmQgSFRUUCBtaWNyb3NlcnZpY2VzIiwic3VtbWFyeSI6IlJldmVyc2UgcHJveHkgZm9yIFNURElPIGFuZCBIVFRQIG1pY3Jvc2VydmljZXMuIENvbnRyaWJ1dGUgdG8gb3BlbmZhYXMvb2Ytd2F0Y2hkb2cgZGV2ZWxvcG1lbnQgYnkgY3JlYXRpbmcgYW4gYWNjb3VudCBvbiBHaXRIdWIuIiwidGVtcGxhdGUiOiJ1c2VfZGVmYXVsdF9mcm9tX3NldHRpbmdzIn0=»]

Este watchdog proporciona varios modos, uno de ellos se llama HTTP y es el predeterminado, y se basa en un reenvío HTTP al servidor interno que se ejecuta en el contenedor. Eso encaja perfectamente con nuestra aplicación Flogo y significa que lo único que necesitamos es desplegar un disparador de solicitud HTTP Receive en nuestra aplicación Flogo y eso es todo.

Las únicas cosas que necesitas configurar son el método (POST) y la Ruta (/) para poder manejar las solicitudes. En nuestro caso vamos a hacer una aplicación simple de Hola Mundo como puedes ver aquí:

Para poder ejecutar esta aplicación necesitamos usar varias cosas, y vamos a explicarlo aquí:

Primero que nada, necesitamos hacer la instalación del entorno OpenFaaS, voy a omitir todos los detalles sobre este proceso y solo señalarte al tutorial detallado sobre ello:

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9ibG9ncy9vcGVuc291cmNlL2RlcGxveS1vcGVuZmFhcy1hd3MtZWtzLyIsImltYWdlX2lkIjotMSwiaW1hZ2VfdXJsIjoiaHR0cHM6Ly9kMjkwOHEwMXZvbXFiMi5jbG91ZGZyb250Lm5ldC9jYTM1MTJmNGRmYTk1YTAzMTY5YzVhNjcwYTRjOTFhMTliMzA3N2I0LzIwMTgvMDkvMTIvb3BlbmZhYXMtZWtzLmpwZyIsInRpdGxlIjoiRGVwbG95IE9wZW5GYWFTIG9uIEFtYXpvbiBFS1MgfCBBbWF6b24gV2ViIFNlcnZpY2VzIiwic3VtbWFyeSI6Ildl4oCZdmUgdGFsa2VkIGFib3V0IEZhYVMgKEZ1bmN0aW9ucyBhcyBhIFNlcnZpY2UpIGluIFJ1bm5pbmcgRmFhUyBvbiBhIEt1YmVybmV0ZXMgQ2x1c3RlciBvbiBBV1MgVXNpbmcgS3ViZWxlc3MgYnkgU2ViYXN0aWVuIEdvYXNndWVuLiBJbiB0aGlzIHBvc3QsIEFsZXggRWxsaXMsIGZvdW5kZXIgb2YgdGhlIE9wZW5GYWFTIHByb2plY3QsIHdhbGtzIHlvdSB0aHJvdWdoIGhvdyB0byB1c2UgT3BlbkZhYVMgb24gQW1hem9uIEVLUy4gT3BlbkZhYVMgaXMgb25lIG9mIHRoZSBtb3N0IHBvcHVsYXIgdG9vbHMgaW4gdGhlIEZhYVPigKYiLCJ0ZW1wbGF0ZSI6InVzZV9kZWZhdWx0X2Zyb21fc2V0dGluZ3MifQ==»]

Ahora necesitamos crear nuestra plantilla y para hacerlo, vamos a usar una plantilla de Dockerfile. Para crearla vamos a ejecutar:

faas-cli new --lang dockerfile

Vamos a nombrar la función flogo-test. Y ahora vamos a actualizar el Dockerfile para que sea así:

La mayor parte de este contenido es común para cualquier otra plantilla que use el nuevo of-watchdog y el modo HTTP.

Me gustaría resaltar las siguientes cosas:

Usamos varias variables de entorno para definir el comportamiento:

mode = HTTP para definir que vamos a usar este método
upstream_url = URL a la que vamos a reenviar la solicitud
fprocess = Comando del sistema operativo que necesitamos ejecutar, en nuestro caso significa ejecutar la aplicación Flogo.

Otras cosas son las mismas que deberías hacer en caso de que quieras ejecutar aplicaciones Flogo en Docker:

Agregar el ejecutable del motor para tu plataforma (UNIX en la mayoría de los casos ya que la base de la imagen es casi siempre basada en Linux)
Agregar el archivo JSON de la aplicación que deseas usar.

También necesitamos cambiar el archivo yml para que se vea así:

version: 1.0
provider:
  name: openfaas
  gateway: http://abc59586cc33f11e9941b069251daa7b-1114483165.eu-west-2.elb.amazonaws.com:8080
functions:
  flogo-test:
    lang: dockerfile
    handler: ./flogo-test
    image: alexandrev/flogo-test:1.7

¡Y eso es todo! Ahora, solo necesitamos ejecutar el siguiente comando:

faas-cli up -f .flogo-test.yml

Y la función se va a desplegar en tu entorno y podemos ejecutarla usando el portal de OpenFaaS directamente:

Todo el código está disponible aquí (lo único que falta es el Flogo Enterprise Engine que necesitas usar para poder construirlo y subirlo)

[visual-link-preview encoded=»eyJ0eXBlIjoiZXh0ZXJuYWwiLCJwb3N0IjowLCJwb3N0X2xhYmVsIjoiIiwidXJsIjoiaHR0cHM6Ly9naXRodWIuY29tL2FsZXhhbmRyZXYvZmxvZ28tb3BlbmZhYXMtbWVkaXVtIiwiaW1hZ2VfaWQiOi0xLCJpbWFnZV91cmwiOiJodHRwczovL29wZW5ncmFwaC5naXRodWJhc3NldHMuY29tLzI1MjI1N2FhYTNjNmUxYzVkY2QxNTJlMzQyMDJkZWQzNzcyMzQ4OGFmM2Y5MDk4NjU1Yjk2NGUzZjBlZDZlYmYvYWxleGFuZHJldi9mbG9nby1vcGVuZmFhcy1tZWRpdW0iLCJ0aXRsZSI6IkdpdEh1YiAtIGFsZXhhbmRyZXYvZmxvZ28tb3BlbmZhYXMtbWVkaXVtOiBFeGFtcGxlIEZsb2dvIEFwcGxpY2F0aW9uIGZvciBEZXBsb3lpbmcgb24gT3BlbkZhYVMiLCJzdW1tYXJ5IjoiRXhhbXBsZSBGbG9nbyBBcHBsaWNhdGlvbiBmb3IgRGVwbG95aW5nIG9uIE9wZW5GYWFTIC0gR2l0SHViIC0gYWxleGFuZHJldi9mbG9nby1vcGVuZmFhcy1tZWRpdW06IEV4YW1wbGUgRmxvZ28gQXBwbGljYXRpb24gZm9yIERlcGxveWluZyBvbiBPcGVuRmFhUyIsInRlbXBsYXRlIjoidXNlX2RlZmF1bHRfZnJvbV9zZXR0aW5ncyJ9″]

Monitoreo de Prometheus en TIBCO Cloud Integration

2025-11-03 por Alexandre Vazquez

En publicaciones anteriores, he explicado cómo integrar aplicaciones de TIBCO BusinessWorks 6.x / BusinessWorks Container Edition (BWCE) con Prometheus, uno de los sistemas de monitoreo más populares para capas en la nube. Prometheus es una de las soluciones más utilizadas para monitorear tus microservicios dentro de un clúster de Kubernetes. En esta publicación, explicaré los pasos para aprovechar Prometheus para integrarse con aplicaciones que se ejecutan en TIBCO Cloud Integration (TCI).

TCI es el iPaaS de TIBCO y principalmente oculta la complejidad de gestión de aplicaciones de una app para los usuarios. Necesitas tu aplicación empaquetada (también conocida como EAR) y manifest.json, ambos generados por el producto para simplemente desplegar la aplicación.

¿No es mágico? ¡Sí, lo es! Como expliqué en mi publicación anterior relacionada con la integración de Prometheus con BWCE, que te permite personalizar tus imágenes base, TCI permite la integración con Prometheus de una manera ligeramente diferente. Vamos a recorrer los pasos.

TCI tiene sus propias herramientas de monitoreo integradas (mostradas a continuación) para proporcionar información sobre la utilización de Memoria y CPU, además del rendimiento de la red, lo cual es muy útil.

Aunque las métricas de monitoreo proporcionadas de fábrica por TCI son suficientes para la mayoría de los escenarios, hay casos de uso de conectividad híbrida (aplicación ejecutándose en las instalaciones y microservicios ejecutándose en tu propio clúster que podría estar en una nube privada o pública) que podrían requerir una vista unificada de monitoreo.

Paso uno es importar el plugin de Prometheus desde la ubicación actual de GitHub a tu espacio de trabajo de BusinessStudio. Para hacer eso, solo necesitas clonar el Repositorio de GitHub disponible aquí: https://github.com/TIBCOSoftware/bw-tooling O https://github.com/alexandrev/bw-tooling

Importa el plugin de Prometheus eligiendo la opción Importar → Plug-ins y Fragmentos y especificando el directorio descargado de la ubicación de GitHub mencionada anteriormente. (mostrado abajo)

Paso dos implica agregar el módulo de Prometheus previamente importado a la aplicación específica como se muestra a continuación:

Paso tres es simplemente construir el archivo EAR junto con manifest.json.

NOTA: Si el EAR no se genera una vez que agregas el plugin de Prometheus, por favor sigue los pasos a continuación:

Exporta el proyecto con el módulo de Prometheus a un archivo zip.
Elimina el proyecto de Prometheus del espacio de trabajo.
Importa el proyecto desde el archivo zip generado antes.

Antes de desplegar la aplicación BW en TCI, necesitamos habilitar un puerto adicional en TCI para extraer las métricas de Prometheus.

Paso cuatro Actualización del archivo manifest.json.

Por defecto, una app de TCI que usa el archivo manifest.json solo expone un puerto para ser consumido desde afuera (relacionado con servicios funcionales) y otro para ser usado internamente para verificaciones de salud.

Para la integración de Prometheus con TCI, necesitamos un puerto adicional escuchando en 9095, para que el servidor de Prometheus pueda acceder a los endpoints de métricas para extraer las métricas requeridas para nuestra aplicación TCI.

Nota: Este documento no cubre los detalles sobre la configuración del servidor de Prometheus (NO es necesario para este PoC) pero puedes encontrar la información relevante en https://prometheus.io/docs/prometheus/latest/installation/

Necesitamos modificar ligeramente el archivo manifest.json generado (de la app BW) para exponer un puerto adicional, 9095 (mostrado abajo).

Además, para decirle a TCI que queremos habilitar el endpoint de Prometheus necesitamos establecer una propiedad en el archivo manifest.json. La propiedad es TCI_BW_CONFIG_OVERRIDES y proporciona el siguiente valor: BW_PROMETHEUS_ENABLE=true, como se muestra a continuación:

También necesitamos agregar una línea adicional (propertyPrefix) en el archivo manifest.json como se muestra a continuación.

Ahora, estamos listos para desplegar la aplicación BW en TCI y una vez que esté desplegada podemos ver que hay dos endpoints

Si expandimos las opciones de Endpoints a la derecha (mostrado arriba), puedes ver que uno de ellos se llama “prometheus” y ese es nuestro endpoint de métricas de Prometheus:

Simplemente copia la URL de prometheus y añádela con /metrics (URL en la captura de pantalla a continuación) — esto mostrará las métricas de Prometheus para la aplicación BW específica desplegada en TCI.

Nota: añadir /metrics no es obligatorio, la URL tal cual para el endpoint de Prometheus también funcionará.

En la lista encontrarás el siguiente tipo de métricas para poder crear los dashboards y análisis más increíbles basados en ese tipo de información:

Métricas JVM sobre memoria utilizada, rendimiento de GC y conteos de pools de hilos
Uso de CPU por la aplicación
Conteos de ejecución de Procesos y Actividades por Estado (Iniciado, Completado, Fallido, Programado..)
Duración por Actividad y Proceso.

Con toda esta información disponible puedes crear dashboards similares al que se muestra a continuación, en este caso usando Spotfire como la herramienta de Dashboard:

Pero también puedes integrar esas métricas con Grafana o cualquier otra herramienta que pueda leer datos de la base de datos de series temporales de Prometheus.