Observability

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.

Prometheus Monitoring for Microservices using TIBCO

We’re living a world with constant changes and this is even more true in the Enterprise Application world. I’ll not spend much time talking about things you already know, but just say that the microservices architecture approach and the PaaS solutions have been a game-changer for all enterprise integration technologies. This time I’d like to […]

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

Configuration | Prometheus

An open-source monitoring system with a dimensional data model, flexible query language, efficient time series database and modern alerting approach.

• 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.

Implementing Custom Service Discovery | Prometheus

An open-source monitoring system with a dimensional data model, flexible query language, efficient time series database and modern alerting approach.

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

- 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

- role: endpoints
    namespaces:
      names:
      - default

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

- 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

• 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.

📚 Want to dive deeper into Kubernetes? This article is part of our comprehensive Kubernetes Architecture Patterns guide, where you’ll find all fundamental and advanced concepts explained step by step.

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

Collection of tools designed to simplify deployment and management of TIBCO BusinessWorks applications – 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.

• 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.