¡Compártelo!
Share on facebook
Share on twitter
Share on linkedin

Registro dinámico en Prometheus

Hoy en día, con el aumento de soluciones y alternativas para desarrollar nuestras aplicaciones, en muchas ocasiones dejamos de lado aspectos tan importantes como la monitorización. Esto, nos aporta un mayor control y dominio del estado de nuestras aplicaciones en los diferentes entornos y contextos. Es por ello, que de entre las soluciones que tenemos, hoy venimos a echar un cable con el registro dinámico en Prometheus.

En este post, daremos por hecho que se ha tenido una toma de contacto previa con esta herramienta ya que hay algunos aspectos que omitiremos, como la conexión y configuración básica de ésta. Aún así, si quieres que te contemos más sobre Prometheus, ¡no tienes más que escribirnos!

Introducción

Cuando nos ponemos a trabajar desde un inicio con Prometheus, normalmente tenemos que configurar la visibilidad de las aplicaciones de manera individual, cosa que en un entorno dinámico y creciente llega a ser inmantenible.

¡Pues bien! Aquí estamos para contaros qué debemos realizar para que Prometheus pueda descubrir automáticamente las aplicaciones que deseamos monitorizar, como ya os habíamos adelantado, en un entorno que aún no es cloud y donde podemos encontrarnos un número variable de instancias para determinadas aplicaciones. 

Para ello, haremos uso de Consul, una herramienta que nos proporciona HashiCorp y que nos ayuda entre otras cosas, con el descubrimiento y registro de nuestras aplicaciones y a centralizar la configuración de estas. Y con todo esto, nos ponemos al lío con un escenario en el que debemos tener corriendo un agente de Consul, de Prometheus y por último, las aplicaciones que deseemos monitorizar, que en este caso consideramos que son Spring boot

Configuración

Para comenzar, en nuestras aplicaciones debemos realizar la comunicación con el servidor de Consul a través del módulo de spring-cloud-starter-consul-discovery, llegando a configurar la propia conexión con el servidor y el nombre de aplicación que nos permitirá identificarla posteriormente, dentro del fichero de propiedades.

La última versión la podréis encontrar aquí.

A continuación, mostramos lo que debemos tener en nuestro pom.xml y application.yaml:

Spring Cloud

Será necesario añadir la dependencia de spring cloud al pom.xml.

  1. Añadir la property con la versión de spring cloud.
<properties>
  <java.version> 1.8 </java.version>
  <spring-cloud.version> Hoxton.SR8 </spring-cloud.version>
</properties>

2. Añadir el dependency managenent

<dependencyManagement>
  <dependencies>
     <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
     </dependency>
  </dependencies>
</dependencyManagement>

3. Añadir consul discovery

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

application.yaml

Deberemos añadir a nuestro application.yaml la siguiente configuración

spring:
 ## Spring app info
 application:
   name: myApplication
 ## Consul
 cloud:
   consul:
     host: localhost
     port: 8500

Configuración del Actuator

Una vez que nuestra aplicación puede registrarse en Consul, debemos pasar a configurar la exposición de las métricas que usará Prometheus para informarnos del estado de nuestra aplicación en el tiempo.
Para ello, debemos  hacer uso de los módulos spring-boot-starter-actuator y micrometer-registry-prometheus. A continuación, os mostramos que debemos tener en nuestro pom.xml y application.yaml.

  1. Spring actuator dependency
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2. Prometheus registry dependency

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

3. Configuración del actuator en application.yaml

management:
 endpoints:
   web:
     exposure:
       include: prometheus,metrics,health,info

Para este caso, únicamente vamos a exponer las siguientes url: /prometheus, /metrics, /health  e /info.
Llegados a este punto, ya tenemos lo necesario para registrarnos en Consul y para devolver la información necesaria para monitorizar nuestras aplicaciones. Para poder validar que toda la configuración está funcionando, podemos consultar la siguiente url http://app:8080/actuator/prometheus (app = host desde el que podemos acceder a nuestra aplicación).

{
  "_links": {
    "self": {
      "href": "http://localhost:8081/actuator",
      "templated": false
    },
    "health": {
      "href": "http://localhost:8081/actuator/health",
      "templated": false
    },
    "health-path": {
      "href": "http://localhost:8081/actuator/health/{*path}",
      "templated": true
    },
    "info": {
      "href": "http://localhost:8081/actuator/info",
      "templated": false
    },
    "prometheus": {
      "href": "http://localhost:8081/actuator/prometheus",
      "templated": false
    },
    "metrics": {
      "href": "http://localhost:8081/actuator/metrics",
      "templated": false
    },
    "metrics-requiredMetricName": {
      "href": "http://localhost:8081/actuator/metrics/{requiredMetricName}",
      "templated": true
    }
  }
}

Prometheus

Ahora, centrándonos en Prometheus, una vez que este esté funcionando tanto si es en nuestra máquina como si es en un contenedor Docker, este se configura a través del  fichero prometheus.yml, el cual debe contener la siguiente información:

scrape_configs:
 - job_name: 'prometheus'
   static_configs:
     - targets: ['127.0.0.1:9090']
 # Applications to monitorize
 - job_name: 'applications'
   metrics_path: '/actuator/prometheus'
   scrape_interval: 5s
   consul_sd_configs:
     - server:   '192.168.1.41:8500'
       #services: ['auth', 'api', 'load-balancer', 'postgres']
   relabel_configs:
   - source_labels: ['__meta_consul_service']
     regex:         '(.*)'
     target_label:  'application'
     replacement:   '$1'

Aquí destacamos el apartado de scrape_configs en el que debemos configurar el consul_ds_configs (2).

Instalación Consul

Finalmente, sólo nos queda echar a andar  nuestro servidor de Consul, cuya instalación puede consultar en el siguiente enlace: (1).
Una vez instalado y con nuestras aplicaciones funcionando, ya podríamos consultar en Consul si éstas ya han sido registradas. En la imagen mostrada a continuación, podemos ver que tenemos a Consul , que en este caso autoregistra las instancias que tenemos corriendo de esta herramienta y nuestra aplicación, cuyo nombre es jenkins.

Prometheus

Conclusión

De este modo, podemos monitorizar nuestras aplicaciones independientemente de las instancias que hayamos ejecutado e incluso de la dirección de las mismas.

En definitiva, si conseguimos que todas las aplicaciones vitales hagan uso de Consul y Prometheus, podríamos obtener una mejor visión de todo el conjunto de aplicaciones, así como establecer alertas (de las cuales os hablaremos en un futuro post) que nos notifiquen posibles situaciones a tener en cuenta para poder intervenir proactivamente y de este modo, conocer en todo momento el estado de nuestras aplicaciones.

Anexo

  1. Instalación Consul: https://www.consul.io/docs/install

https://learn.hashicorp.com/tutorials/consul/docker-container-agents (docker)

  1. Documentación de Prometheus para usar consul14
    https://prometheus.io/blog/2015/06/01/advanced-service-discovery/#discovery-with-consul

Artículos relacionados

Que es TypeScript

TypeScript: qué es, diferencias con JavaScript y por qué aprenderlo

Si te dedicas al desarrollo Front-End o al desarrollo de software en general, seguramente hayas oído hablar de TypeScript, o incluso lo utilizas en tu día a día. Pero a los que simplemente tienen curiosidad por el mundo de la programación, a lo mejor, no

Mejores frameworks de Java en 2021

Los mejores frameworks de Java en 2021 para desarrollo web

En este artículo vamos a diseccionar los mejores frameworks de Java en 2021, aquellos marcos de trabajo imprescindibles para desarrollar aplicaciones web con Java en la actualidad. Java es uno de los lenguajes de programación más utilizados por los desarrolladores hoy en día y uno

qué es Gherkin

Qué es Gherkin: cómo usarlo y cuáles son sus elementos

En este post explicamos qué es Gherkin, un lenguaje DSL (lenguaje de dominio específico) muy cercano al lenguaje natural. Repasamos cómo usarlo y cuáles son sus elementos. Comprendiendo el marco dónde se aplica Gherkin: del TDD al BDD Igual que una planta crece hacia el