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

Registro dinámico en Prometheus

Introducción

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 éste. Aún así, si quieres que te contemos más sobre Prometheus, ¡no tienes más que escribirnos!.
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

QA en el desarrollo de software

La importancia del QA en el desarrollo de software

¿Entregarías un proyecto al cliente sin asegurarte de que funciona todo tal y como se especificó en la toma de requerimientos? ¿Es necesario hacer pruebas durante todo el desarrollo de un proyecto o solo en la fase final? En un proyecto con metodología scrum, ¿dónde

Qué es Ionic

Qué es Ionic y por qué utilizarlo para desarrollar aplicaciones móviles híbridas

Ionic es un SDK de front-end de código abierto basado en tecnologías web (HTML, CSS y JS) que es utilizado para desarrollar aplicaciones móviles híbridas. Ionic proporciona una librería de componentes híbridos optimizada para dispositivos móviles. Su compatibilidad y, gracias a la implementación de Cordova

Ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM

Ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM

En este post te mostramos paso a paso cómo ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM, para conseguir que nuestras aplicaciones arranquen más rápido y tengan un menor consumo de memoria. Uso de memoria en Java Como todos sabemos, Java es uno de