Observabilidad en un Ecosistema de Microservicios Políglota

Observabilidad en un Ecosistema de Microservicios Políglota

Aprende a gestionar los requisitos de observabilidad como parte de tu ecosistema de microservicios

“Que vivas en tiempos interesantes” es la traducción al inglés de la maldición china, y esto no podría ser más cierto como descripción de los tiempos en los que vivimos en cuanto a nuestra arquitectura de aplicaciones y desarrollo de aplicaciones.

Todos los cambios del enfoque nativo de la nube, incluyendo todas las nuevas tecnologías que vienen con él, como contenedores, microservicios, API, DevOps, etc., han transformado completamente la situación para cualquier arquitectura, desarrollador o administración de sistemas.

Es algo similar si te fuiste a la cama en 2003 y te despiertas en 2020, todos los cambios, todas las nuevas filosofías, pero también todos los desafíos únicos que vienen con los cambios y nuevas capacidades son cosas con las que necesitamos lidiar hoy.

Creo que todos podemos estar de acuerdo en que el presente es políglota en términos de desarrollo de aplicaciones. Hoy no se espera que ninguna gran empresa o corporación encuentre una tecnología disponible, un lenguaje disponible para soportar todos sus productos internos. Hoy todos seguimos y estamos de acuerdo con el principio de “la herramienta adecuada para el trabajo adecuado” para intentar crear nuestro conjunto de herramientas de tecnologías que vamos a usar para resolver diferentes casos de uso o patrones que necesitas enfrentar.

Pero ese acuerdo y movimiento también vienen con su desafío respecto a cosas en las que usualmente no pensamos, como el rastreo y la observabilidad en general.

Cuando usamos una sola tecnología, todo es más sencillo. Definir una estrategia común para rastrear tus flujos de extremo a extremo es fácil; solo necesitas incrustar la lógica en tu marco de desarrollo común o biblioteca que todos tus desarrollos están usando. Probablemente definir una arquitectura de encabezado típica con todos los datos que necesitas para poder rastrear efectivamente todas las solicitudes y definir un protocolo estándar para enviar todos esos rastros a un sistema estándar que pueda almacenarlos y correlacionarlos todos y explicar el flujo de extremo a extremo. Pero intenta mover eso a un ecosistema políglota: ¿Debería escribir mi marco o biblioteca para cada lenguaje o tecnología que necesitaría usar, o también puedo usar en el futuro? ¿Tiene sentido eso?

Pero no solo eso, ¿debería ralentizar la adopción de una nueva tecnología que puede ayudar rápidamente al negocio porque necesito proporcionar desde un equipo compartido este tipo de componentes estándar? Ese es el mejor caso en el que tengo suficiente gente que sabe cómo funcionan los internos de mi marco y tiene las habilidades en todos los lenguajes que estamos adoptando para poder hacerlo rápidamente y de manera eficiente. Parece poco probable, ¿verdad?

Entonces, a nuevos desafíos también nuevas soluciones. Ya he estado hablando sobre Service Mesh respecto a las capacidades que proporciona desde una perspectiva de comunicación, y si no lo recuerdas, puedes echar un vistazo a esas publicaciones:

Pero también proporciona capacidades desde otras perspectivas y el rastreo y la observabilidad es una de ellas. Porque cuando no podemos incluir esas características en cualquier tecnología que necesitemos usar, podemos hacerlo en una tecnología general que sea compatible con todas ellas, y ese es el caso con Service Mesh.

Como Service Mesh es la forma estándar de comunicar sincrónicamente tus microservicios en una comunicación de este a oeste cubriendo la comunicación de servicio a servicio. Entonces, si puedes incluir en ese componente también la capacidad de rastreo, puedes tener un rastreo de extremo a extremo sin necesidad de implementar nada en cada una de las diferentes tecnologías que puedes usar para implementar la lógica que necesitas, así que, has cambiado de la Figura A a la Figura B en la imagen a continuación:

Observabilidad en un Ecosistema de Microservicios Políglota
Implementación de lógica de rastreo en la aplicación vs. Soporte de rastreo de Service Mesh 

Y eso es lo que la mayoría de las tecnologías de Service Mesh están haciendo. Por ejemplo, Istio, como una de las opciones predeterminadas cuando se trata de Service Mesh, incluye una implementación del estándar OpenTracing que permite la integración con cualquier herramienta que soporte el estándar para poder recopilar toda la información de rastreo para cualquier tecnología que se use para comunicarse a través de la malla.

Entonces, ese cambio de mentalidad nos permite integrar fácilmente diferentes tecnologías sin necesidad de ningún soporte excepcional de esos estándares para cualquier tecnología específica. ¿Significa eso que la implementación de esos estándares para esas tecnologías no es necesaria? En absoluto, eso sigue siendo relevante, porque las que también soportan esos estándares pueden proporcionar aún más información. Después de todo, el Service Mesh solo conoce parte de la información que es el flujo que está sucediendo fuera de cada tecnología. Es algo similar a un enfoque de caja negra. Pero también agregar el soporte para cada tecnología al mismo estándar proporciona un enfoque adicional de caja blanca como puedes ver gráficamente en la imagen a continuación:

Observabilidad en un Ecosistema de Microservicios Políglota
Combinación de datos de rastreo de caja blanca y datos de rastreo de caja negra 

Ya hablamos sobre el cumplimiento de algunas tecnologías con el estándar OpenTracing como TIBCO BusinessWorks Container Edition que puedes recordar aquí:

Entonces, también, el soporte de estas tecnologías de los estándares de la industria es necesario e incluso una ventaja competitiva porque sin necesidad de desarrollar tu marco de rastreo, puedes lograr un enfoque de Datos de Rastreo Completo adicional a lo que ya proporciona el nivel de Service Mesh en sí mismo.

Métricas de Prometheus: ¿Cómo cambiar el nombre de la métrica?

Métricas de Prometheus: ¿Cómo cambiar el nombre de la métrica?

Encuentra una manera de redefinir y reorganizar el nombre de tus métricas de Prometheus para cumplir con tus requisitos

Prometheus se ha convertido en el nuevo estándar cuando hablamos de monitorear nuestra nueva arquitectura de aplicaciones modernas, y necesitamos asegurarnos de conocer todas sus opciones para asegurarnos de obtener lo mejor de él. Lo he estado usando durante algún tiempo hasta que me di cuenta de una característica que estaba desesperado por saber cómo hacer, pero no pude encontrar en ningún lugar claramente definido. Así que como no lo encontré fácilmente, pensé en escribir un pequeño artículo para mostrarte cómo hacerlo sin necesidad de gastar el mismo tiempo que yo.

Tenemos mucha información sobre cómo configurar Prometheus y usar algunos de los complementos de configuración habituales, como podemos ver en su página web oficial [1]. Incluso ya escribí sobre alguna configuración y usándolo para varios propósitos, como también puedes ver en otras publicaciones [2][3][4].

Uno de estos complementos de configuración es sobre el reetiquetado, y esto es algo genial. Tenemos que cada uno de los exportadores puede tener sus etiquetas y significado para ellas, y cuando intentas gestionar diferentes tecnologías o componentes hace complejo que todos ellos coincidan juntos incluso si todos ellos siguen la convención de nombres que tiene Prometheus [5].

Pero tuve esta situación, y estoy seguro de que tú también has pasado o pasarás por eso, que tengo métricas similares para diferentes tecnologías que para mí son las mismas, y necesito mantenerlas con el mismo nombre, pero como pertenecen a otras tecnologías no lo son. Así que necesito encontrar una manera de renombrar la métrica, y lo genial es que puedes hacer eso.

Para hacer eso, solo necesitas hacer una configuración de metric_relabel. Esta configuración se aplica para reetiquetar (como el nombre ya indica) etiquetas de tus métricas de prometheus en este caso antes de ser ingeridas, pero también nos permite usar algunos términos notables para hacer diferentes cosas, y uno de estos términos notables es __name__. __name__ es una etiqueta particular que te permitirá renombrar tus métricas de prometheus antes de ser ingeridas en la Base de Datos de Series Temporales de Prometheus. Y después de ese punto, esto será como si tuviera ese nombre desde el principio.

Cómo usar eso es relativamente fácil, es como cualquier otro proceso de reetiquetado, y me gustaría mostrarte un ejemplo sobre cómo hacerlo.

- source_labels: [__name__]
regex:  'jvm_threads_current'
target_label: __name__
replacement: 'process_thread_count'

Aquí hay un ejemplo simple para mostrar cómo podemos renombrar un nombre de métrica jvm_threads_current para contar los hilos dentro de la máquina JVM para hacerlo más genérico y poder incluir los hilos para el proceso en una métrica de prometheus process_thread_count que ahora podemos usar como si fuera el nombre original.


Referencias

[1] Prometheus: Configuración https://prometheus.io/docs/prometheus/latest/configuration/configuration/

[2] https://medium.com/@alexandrev/prometheus-monitoring-in-tibco-cloud-integration-96a6811416ce

[3] https://medium.com/@alexandrev/prometheus-monitoring-for-microservices-using-tibco-772018d093c4

[4] https://medium.com/@alexandrev/kubernetes-service-discovery-for-prometheus-fcab74237db6

[5] Prometheus: Nomenclatura de Métricas y Etiquetas https://prometheus.io/docs/practices/naming/

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

Monitoreo de Prometheus en TIBCO Cloud Integration

Monitoreo de Prometheus en TIBCO Cloud Integration

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)

Monitoreo de Prometheus en TIBCO Cloud Integration
Monitoreo de Prometheus en TIBCO Cloud Integration

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

Monitoreo de Prometheus en TIBCO Cloud Integration

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.

Monitoreo de Prometheus en TIBCO Cloud Integration

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

Monitoreo de Prometheus en TIBCO Cloud Integration

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:

Monitoreo de Prometheus en TIBCO Cloud Integration

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

Monitoreo de Prometheus en TIBCO Cloud Integration

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

Monitoreo de Prometheus en TIBCO Cloud Integration

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

Monitoreo de Prometheus en TIBCO Cloud Integration

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:

Monitoreo de Prometheus en TIBCO Cloud Integration

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.

Monitoreo de Prometheus en TIBCO Cloud Integration

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

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

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

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

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
Usar estadísticas a tu favor para detectar cuellos de botella en TIBCO BusinessWorks Container Edition

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
Usar estadísticas a tu favor para detectar cuellos de botella en TIBCO BusinessWorks Container Edition

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:

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

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!

Descubrimiento de servicios de Kubernetes para Prometheus

Descubrimiento de servicios de Kubernetes para Prometheus
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í. 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:
  • 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í: 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”

📚 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 TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!

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

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.

¿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
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • Navegar a la carpeta prometheus-integration (descomprimida en el paso 1)
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • 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.
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • 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.
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • Hacer clic derecho en Plugin → Exportar → Exportar…
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • Seleccionar tipo como archivo JAR y hacer clic en Siguiente
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • Ahora hacer clic en Siguiente → Siguiente → seleccionar el botón de radio para usar el archivo MANIFEST.MF existente y buscar el archivo manifest
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!
  • 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

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

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.
Prometheus TIBCO Monitoring para Contenedores: ¡Rápido y Sencillo en 5 Minutos!

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.

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

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

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

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.

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

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

El mes pasado, durante el KubeCon 2019 Europa en Barcelona, OpenTracing anunció su fusión con el proyecto OpenCensus para crear un nuevo estándar llamado OpenTelemetry que estará disponible en septiembre de 2019.

Entonces, creo que sería increíble echar un vistazo a las capacidades relacionadas con OpenTracing que tenemos disponibles en TIBCO BusinessWorks Container Edition.

El mundo de hoy es demasiado complejo en términos de cómo se definen y gestionan nuestras arquitecturas. Nuevos conceptos en los últimos años como contenedores, microservicios, malla de servicios, nos dan la opción de alcanzar un nuevo nivel de flexibilidad, rendimiento y productividad, pero también viene con un costo de gestión con el que necesitamos lidiar.

Hace años, las arquitecturas eran más simples, el servicio era un concepto que estaba comenzando, pero incluso entonces comenzaron a surgir algunos problemas relacionados con el monitoreo, rastreo, registro, etc. Entonces, en esos días todo se resolvía con un Marco de Desarrollo que todos nuestros servicios iban a incluir porque todos nuestros servicios eran desarrollados por el mismo equipo, la misma tecnología, y en ese marco, podíamos asegurarnos de que las cosas se manejaban correctamente.

Ahora, confiamos en estándares para hacer este tipo de cosas, y por ejemplo, para el rastreo, confiamos en OpenTracing. No quiero pasar tiempo hablando sobre qué es OpenTracing, donde tienen una cuenta completa en Medium hablando ellos mismos mucho mejor de lo que yo podría hacerlo, así que por favor tómate unos minutos para leer sobre ello.

La única declaración que quiero hacer aquí es la siguiente:

El rastreo no es registro, y por favor asegúrate de entender eso.

El rastreo se trata de muestreo, es como cómo se están desempeñando los flujos y si todo está funcionando, pero no se trata de si una solicitud específica se ha realizado bien para el ID de cliente que sea… eso es registro, no rastreo.

Así que OpenTracing y sus diferentes implementaciones como Jaeger o Zipkin son la forma en que podemos implementar el rastreo hoy de una manera realmente fácil, y esto no es algo que solo podrías hacer en tu lenguaje de desarrollo basado en código, puedes hacerlo con nuestras herramientas sin código para desarrollar aplicaciones nativas de la nube como TIBCO BusinessWorks Container Edition y eso es lo que me gustaría mostrarte hoy. Así que, que comience el partido…

Lo primero que me gustaría hacer es mostrarte el escenario que vamos a implementar, y este va a ser el que se muestra en la imagen a continuación:

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Vas a tener dos servicios REST que se van a llamar entre sí, y vamos a exportar todos los rastros al componente externo Jaeger y luego podemos usar su interfaz para analizar el flujo de una manera gráfica y fácil.

Entonces, lo primero que necesitamos hacer es desarrollar los servicios que, como puedes ver en las imágenes a continuación, van a ser bastante fáciles porque este no es el propósito principal de nuestro escenario.

Una vez que tengamos nuestras imágenes de Docker basadas en esas aplicaciones, podemos comenzar, pero antes de lanzar nuestras aplicaciones, necesitamos lanzar nuestro sistema Jaeger, puedes leer toda la información sobre cómo hacerlo en el enlace a continuación:

Pero al final solo necesitamos ejecutar el siguiente comando:

docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HTTP_PORT=9411  -p 5775:5775/udp  -p 6831:6831/udp  -p 6832:6832/udp  -p 5778:5778  -p 16686:16686  -p 14268:14268  -p 9411:9411  jaegertracing/all-in-one:1.8

Y ahora, estamos listos para lanzar nuestras aplicaciones y lo único que necesitamos hacer en nuestros desarrollos, porque como pudiste ver no hicimos nada extraño en nuestro desarrollo y fue bastante sencillo, es agregar las siguientes variables de entorno cuando lancemos nuestro contenedor

BW_JAVA_OPTS=”-Dbw.engine.opentracing.enable=true” -e JAEGER_AGENT_HOST=jaeger -e JAEGER_AGENT_PORT=6831 -e JAEGER_SAMPLER_MANAGER_HOST_PORT=jaeger:5778

Y… eso es todo, lanzamos nuestros contenedores con los siguientes comandos y esperamos hasta que las aplicaciones estén en funcionamiento

docker run -ti -p 5000:5000 — name provider -e BW_PROFILE=Docker -e PROVIDER_PORT=5000 -e BW_LOGLEVEL=ERROR — link jaeger -e BW_JAVA_OPTS=”-Dbw.engine.opentracing.enable=true” -e JAEGER_AGENT_HOST=jaeger -e JAEGER_AGENT_PORT=6831 -e JAEGER_SAMPLER_MANAGER_HOST_PORT=jaeger:5778 provider:1.0
Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition
docker run — name consumer -ti -p 6000:6000 -e BW_PROFILE=Docker — link jaeger — link provider -e BW_JAVA_OPTS=”-Dbw.engine.opentracing.enable=true” -e JAEGER_AGENT_HOST=jaeger -e JAEGER_AGENT_PORT=6831 -e JAEGER_SAMPLER_MANAGER_HOST_PORT=jaeger:5778 -e CONSUMER_PORT=6000 -e PROVIDER_HOST=provider consumer:1.0
Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Una vez que estén en funcionamiento, ¡generemos algunas solicitudes! Para hacer eso, voy a usar un proyecto SOAPUI para generar una carga estable durante 60 segundos, como puedes ver en la imagen a continuación:

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Y ahora vamos a ir a la siguiente URL para ver la interfaz de Jaeger y podemos ver lo siguiente tan pronto como hagas clic en el botón de búsqueda

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Y luego, si hacemos zoom en algún rastro específico:

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Eso es bastante asombroso, pero eso no es todo, porque puedes ver si buscas en la interfaz sobre los datos de estos rastros, puedes ver datos técnicos de tus flujos de BusinessWorks Container Edition, como puedes ver en la imagen a continuación:

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Pero… ¿qué pasa si quieres agregar tus etiquetas personalizadas a esos rastros? ¡También puedes hacerlo! Déjame explicarte cómo.

Desde BusinessWorks Container Edition 2.4.4 vas a encontrar una nueva pestaña en todas tus actividades llamada «Etiquetas» donde puedes agregar las etiquetas personalizadas que deseas que esta actividad incluya, por ejemplo, un id personalizado que se va a propagar a través de todo el proceso, podemos definirlo como puedes ver aquí.

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Y si echas un vistazo a los datos que tenemos en el sistema, puedes ver que todos estos rastros tienen estos datos:

Compatibilidad con OpenTracing en TIBCO BusinessWorks Container Edition

Puedes echar un vistazo al código en el siguiente repositorio de GitHub:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Introducción

Las sondas son cómo podemos decirle a Kubernetes que todo dentro del pod está funcionando como se espera. Kubernetes no tiene forma de saber qué está sucediendo dentro a nivel detallado y no tiene forma de saber para cada contenedor si está saludable o no, por eso necesitan ayuda del propio contenedor.

Imagina que eres el controlador de Kubernetes y tienes como ocho pods diferentes, uno con una aplicación por lotes de Java, otro con alguna instancia de Redis, otro con una aplicación de nodejs, otro con un microservicio de Flogo (Nota: ¿Aún no has oído hablar de TIBCO Flogo? Tómate unos minutos para conocer una de las próximas novedades que puedes usar ahora para construir tus aplicaciones nativas en la nube), otro con una base de datos Oracle, otro con algún servidor web jetty y finalmente otro con una aplicación de BusinessWorks Container Edition. ¿Cómo puedes saber que cada componente está funcionando bien?

Primero, puedes pensar que puedes hacerlo con el componente de punto de entrada de tu Dockerfile ya que solo especificas un comando para ejecutar dentro de cada contenedor, así que verifica si ese proceso está en ejecución, ¿y eso significa que todo está saludable? Ok… bastante justo…

Pero, ¿esto es siempre cierto? ¿Un proceso en ejecución a nivel de SO/contenedor significa que todo está funcionando bien? Pensemos en la base de datos Oracle por un minuto, imagina que tienes un problema con la memoria compartida y se mantiene en un estado de inicialización para siempre, K8S va a verificar el comando, va a encontrar que está en ejecución y le dice a todo el clúster: ¡Ok! ¡No te preocupes! La base de datos está funcionando perfectamente, ¡adelante y envía tus consultas a ella!

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Foto de Rod Long en Unsplash

Esto podría suceder con componentes similares como un servidor web o incluso con una aplicación en sí, pero es muy común cuando tienes servidores que pueden manejar implementaciones en él, como BusinessWorks Container Edition en sí. Y por eso esto es muy importante para nosotros como desarrolladores e incluso más importante para nosotros como administradores. ¡Así que empecemos!

Lo primero que vamos a hacer es construir una aplicación de BusinessWorks Container Edition, como este no es el propósito principal de este artículo, vamos a usar las mismas que he creado para la Integración de BusinessWorks Container Edition — Istio que puedes encontrar aquí.

Entonces, esta es una aplicación bastante simple que expone un servicio web SOAP. Todas las aplicaciones en BusinessWorks Container Edition (así como en BusinessWorks Enterprise Edition) tienen su propio estado, por lo que puedes preguntarles si están en ejecución o no, eso es algo que el «motor» interno de BusinessWorks Container (NOTA: Vamos a usar la palabra motor para simplificar cuando hablamos de los internos de BWCE. En detalle, el componente que conoce el estado de la aplicación es el AppNode interno que inicia el contenedor, pero mantengámoslo simple por ahora)

Sondas de Kubernetes

En Kubernetes, existe el concepto de «sonda» para realizar verificaciones de salud a tu contenedor. Esto se realiza configurando sondas de vivacidad o sondas de preparación.

  • Sonda de vivacidad: Kubernetes utiliza sondas de vivacidad para saber cuándo reiniciar un contenedor. Por ejemplo, las sondas de vivacidad podrían detectar un bloqueo, donde una aplicación está en ejecución, pero no puede avanzar.
  • Sonda de preparación: Kubernetes utiliza sondas de preparación para saber cuándo un contenedor está listo para comenzar a aceptar tráfico. Un pod se considera listo cuando todos sus contenedores están listos. Un uso de esta señal es controlar qué pods se utilizan como backends para los servicios. Cuando un pod no está listo, se elimina del balance de carga del servicio

Incluso cuando hay dos tipos de sondas para BusinessWorks Container Edition, ambas se manejan de la misma manera, la idea es la siguiente: Mientras la aplicación esté en ejecución, puedes comenzar a enviar tráfico y cuando no esté en ejecución necesitamos reiniciar el contenedor, por lo que eso lo hace más simple para nosotros.

Implementación de Sondas

Cada aplicación de BusinessWorks Container Edition que se inicia tiene una forma predeterminada de saber si está saludable o no. Esto se hace mediante un endpoint especial publicado por el propio motor:

http://localhost:7777/_ping/

Entonces, si tenemos una aplicación normal de BusinessWorks Container Edition desplegada en nuestro clúster de Kubernetes como la que teníamos para la integración de Istio, tenemos registros similares a estos:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Trazas de inicio de una aplicación de BusinessWorks Container Edition

Como puedes ver, los registros dicen que la aplicación está iniciada. Entonces, como no podemos lanzar una solicitud curl desde dentro del contenedor (ya que no hemos expuesto el puerto 7777 al exterior aún y curl no está instalado en la imagen base), lo primero que vamos a hacer es exponerlo al resto del clúster.

Para hacer eso, cambiamos nuestro archivo Deployment.yml que hemos usado a este:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Archivo Deployment.yml con el puerto 7777 expuesto

Ahora, podemos ir a cualquier contenedor en el clúster que tenga «curl» instalado o cualquier otra forma de lanzar una solicitud como esta con el código HTTP 200 y el mensaje «La aplicación está en ejecución».

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Ejecución exitosa del endpoint _ping

NOTA: Si olvidas la última / e intentas invocar _ping en lugar de _ping/ vas a obtener un código HTTP 302 Found con la ubicación final como puedes ver aquí:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Ejecución del código HTTP 302 apuntando a _ping en lugar de _ping/

Ok, veamos qué pasa si ahora detenemos la aplicación. Para hacer eso vamos a entrar en el contenedor y usar la consola OSGi.

Para hacer eso, una vez que estés dentro del contenedor, ejecutas el siguiente comando:

ssh -p 1122 equinox@localhost

Va a pedir credenciales y usa la contraseña predeterminada ‘equinox’. Después de eso, te dará la oportunidad de crear un nuevo usuario y puedes usar las credenciales que te funcionen. En mi ejemplo, voy a usar admin / adminadmin (NOTA: La longitud mínima para una contraseña es de ocho (8) caracteres.

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Y ahora, estamos dentro. Y esto nos permite la opción de ejecutar varios comandos, como este no es el tema principal de hoy voy a omitir toda la explicación, pero puedes echar un vistazo a este enlace con toda la información sobre esta consola.

Si ejecutamos frwk:la va a mostrar las aplicaciones desplegadas, en nuestro caso la única, como debería ser en la aplicación de BusinessWorks Container Edition:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Para detenerla, vamos a ejecutar el siguiente comando para listar todos los paquetes OSGi que tenemos en este momento en ejecución en el sistema:

frwk:lb

Ahora, encontramos los paquetes que pertenecen a nuestra aplicación (al menos dos paquetes (1 por módulo BW y otro para la aplicación)

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Mostrando paquetes dentro de la aplicación BusinessWorks Container

Y ahora podemos detenerlo usando felix:stop <ID>, así que en mi caso, necesito ejecutar los siguientes comandos:

stop “603”

stop “604”

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Comandos para detener los paquetes que pertenecen a la aplicación

Y ahora la aplicación está detenida

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Consola OSGi mostrando la aplicación como Detenida

Entonces, si ahora intentamos lanzar el mismo comando curl que ejecutamos antes, obtenemos la siguiente salida:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition
Ejecución fallida del endpoint ping cuando la aplicación está detenida

Como puedes ver, un error HTTP 500 que significa que algo no está bien. Si ahora intentamos iniciar nuevamente la aplicación usando el comando de inicio de paquete (equivalente al comando de detención de paquete que usamos antes) para ambos paquetes de la aplicación, verás que la aplicación dice que está en ejecución nuevamente:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Y el comando tiene la salida HTTP 200 como debería tener y el mensaje «La aplicación está en ejecución»

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Entonces, ahora, después de saber cómo funciona el endpoint _ping/ solo necesitamos agregarlo a nuestro archivo deployment.yml de Kubernetes. Así que modificamos nuevamente nuestro archivo de implementación para que sea algo como esto:

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

NOTA: Es bastante importante la presencia del parámetro initialDelaySeconds para asegurarse de que la aplicación tenga la opción de iniciarse antes de comenzar a ejecutar la sonda. En caso de que no pongas este valor, puedes obtener un bucle de reinicio en tu contenedor.

NOTA: El ejemplo muestra el puerto 7777 como un puerto exportado, pero esto solo es necesario para los pasos que hemos hecho antes y no será necesario en un entorno de producción real.

Así que ahora desplegamos nuevamente el archivo YML y una vez que tengamos la aplicación en ejecución, vamos a intentar el mismo enfoque, pero ahora como tenemos las sondas definidas tan pronto como detenga la aplicación, los contenedores se reiniciarán. ¡Veamos!

Sondas de Kubernetes para una aplicación de TIBCO BusinessWorks Container Edition

Como puedes ver en la imagen de arriba, después de que la aplicación se detiene, el contenedor se ha reiniciado y debido a eso, hemos sido expulsados de dentro del contenedor.

Así que eso es todo, espero que te ayude a configurar tus sondas y en caso de que necesites más detalles, por favor echa un vistazo a la documentación de Kubernetes sobre sondas httpGet para ver toda la configuración y opciones que puedes aplicarles.