Supervisión de aplicaciones Spring Boot con Micrometer, Prometheus y Grafana

Supervisar el estado de una aplicación nos ayuda a administrarla y mejorar la optimización y el rendimiento. En este artículo, usaremos Micrometer, Prometheus y Grafana para monitorear de cerca una aplicación Spring Boot.

Introducción

Supervisar el estado y las métricas de una aplicación nos ayuda a gestionarla mejor, detectar comportamientos no optimizados y acercarnos a su rendimiento. Esto es especialmente cierto cuando estamos desarrollando un sistema con muchos microservicios, donde el monitoreo de cada servicio puede resultar crucial cuando se trata de mantener nuestro sistema.

Basándonos en esta información, podemos sacar conclusiones y decidir qué microservicio necesita escalar si no se pueden lograr más mejoras de rendimiento con la configuración actual.

En este artículo, cubriremos cómo monitorear las aplicaciones web de Spring Boot. Usaremos tres proyectos para lograr esto:

  • Micrómetro: Expone las métricas de nuestra aplicación
  • Prometeo: almacena nuestros datos métricos
  • Grafana: Visualiza nuestros datos en gráficos

Esto puede parecer mucho, especialmente en comparación con solo usar el proyecto Actuador de bota de resorte, pero es muy fácil implementarlos todos con solo unas pocas configuraciones.

Para facilitar aún más las cosas, usaremos Estibador para ejecutar Prometheus y Grafana, ya que ambos tienen imágenes oficiales de Docker. Si no estás familiarizado con Docker, puedes consultar nuestro artículo Docker: una introducción de alto nivel.

Tenga en cuenta que estas métricas le brindarán información agregada durante un intervalo de tiempo. Si desea verificar información sobre una solicitud individual en un momento determinado y qué sucedió con ella, entonces esta podría no ser la solución para usted.

In that case, you probably need a distributed tracing system which we have covered in detail in Seguimiento distribuido con Sleuth.

Actuador de arranque con resorte

Comenzaremos con un servicio REST simple usando Spring Initializr que contiene un punto final único de /hello y se ejecuta en el puerto predeterminado de 8080.

Además, esta aplicación también cuenta con la dependencia spring-boot-starter-actuator, que proporciona [terminales listos para producción](https://docs.spring.io/spring-boot/docs/current/reference/html/production -ready-endpoints.html) que puede usar para su aplicación. Estos puntos finales se encuentran bajo un prefijo común de /actuador y están, de forma predeterminada, protegidos.

Expóngalos individualmente, o todos a la vez, agregando las siguientes propiedades en application.properties:

1
management.endpoints.web.exposure.include=*

Para verificar, naveguemos nuestro navegador a http://localhost:8080/actuator:

spring boot monitor actuator

Puede ver todos los puntos finales que expone Actuator, como /health, /metrics, /mappings, etc. Abramos el punto final /metrics del Actuator navegando nuestro navegador a http ://localhost:8080/actuador/métricas:

spring boot monitor mappings and endpoints

Como puede ver, aquí hay mucha información sobre nuestra aplicación, como información sobre subprocesos, sesiones de Tomcat, clases, el búfer, etc. Profundicemos y recuperemos información sobre la memoria JVM utilizada:

spring boot monitor actuator metrics memeory

Ahora, usar Spring Boot Actuator de esta manera produce mucha información sobre su aplicación, pero no es muy fácil de usar. Se puede integrar con Administrador de Spring Boot para visualización, pero tiene sus limitaciones y es menos popular.

Herramientas como Prometheus, atlas de netflix y Grafana se usan más comúnmente para el monitoreo y la visualización y son independientes del lenguaje/marco.

Cada una de estas herramientas tiene su propio conjunto de formatos de datos y convertir los datos /metrics para cada uno sería una molestia. Para evitar convertirlos nosotros mismos, necesitamos un proveedor de datos independiente del proveedor, como Micrometer.

Micrómetro

Para resolver este problema de ser un proveedor de datos independiente del proveedor, surgió Micrometer. Expone las métricas de Actuator a sistemas de monitoreo externos como Prometheus, Netflix Atlas, Vigilancia de la nube de AWS y muchos más.

Se describen correctamente como:

Piensa en SLF4J, pero para métricas.

Como repaso, SLF4J es una fachada de registro para otros marcos de registro de Java. SLF4J en sí mismo no tiene ninguna implementación de registro. La idea es que escriba el código utilizando las API de SLF4J y la implementación real provenga del marco que elija. Podría ser cualquiera de los marcos populares como log4j, volver a iniciar sesión, etc.

De manera similar, Micrometer expone automáticamente los datos /actuador/métricas en algo que su sistema de monitoreo pueda entender. Todo lo que necesita hacer es incluir esa dependencia micrométrica específica del proveedor en su aplicación.

Micrometer es un proyecto independiente de código abierto y no está en el ecosistema de Spring, por lo que debemos agregarlo explícitamente como una dependencia. Ya que usaremos Prometheus, agreguemos su dependencia específica en nuestro pom.xml:

1
2
3
4
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Reconstruya e inicie la aplicación y navegue nuestro navegador a http://localhost:8080/actuator:

spring boot monitor actuator prometheus

Esto generará un nuevo punto final: /actuator/prometheus. Al abrirlo, verá datos con formato específico para Prometheus:

spring boot monitor actuator prometheus data

Prometeo

Prometheus es una base de datos de series temporales que almacena nuestros datos métricos extrayéndolos (usando un raspador de datos incorporado) periódicamente a través de HTTP. Los intervalos entre extracciones se pueden configurar, por supuesto, y tenemos que proporcionar la URL desde la que extraer. También tiene una interfaz de usuario simple donde podemos visualizar/consultar todas las métricas recopiladas.

Configuremos Prometheus, y más precisamente el intervalo de raspado, los objetivos, etc. Para hacer eso, usaremos el archivo prometheus.yml:

1
2
3
4
5
6
7
8
9
global:
  scrape_interval: 10s

scrape_configs:
  - job_name: 'spring_micrometer'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['192.168.2.8:8080']

Como puede ver, tenemos una clave raíz scrape_configs donde podemos definir una lista de trabajos y especificar la URL, la ruta de las métricas y el intervalo. Si desea leer más sobre las configuraciones de Prometheus, no dude en visitar la documentación oficial.

Nota: Dado que estamos usando Docker para ejecutar Prometheus, se ejecutará en una red de Docker que no entenderá localhost/120.0.01, como es de esperar. Dado que nuestra aplicación se ejecuta en localhost, y para el contenedor Docker, localhost significa su propia red, tenemos que especificar la IP de nuestro sistema en su lugar.

Entonces, en lugar de usar locahost:8080, se usa 192.168.2.8:8080 donde 192.168.2.8 es la IP de mi PC en este momento.

Para verificar la IP de su sistema, puede ejecutar ipconfig o ifconfig en su terminal, dependiendo de su sistema operativo.

Ahora, podemos ejecutar Prometheus usando el comando Docker:

1
$ docker run -d -p 9090:9090 -v <path-to-prometheus.yml>:/etc/prometheus/prometheus.yml prom/prometheus

<path-to-prometheus.yml> es donde su propio prometheus.yml comienza desde la raíz. Por ejemplo, esto funciona en mi PC local con Windows:

1
$ docker run -d -p 9090:9090 -v $PWD/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

Para ver el panel de control de Prometheus, navegue con su navegador a http://localhost:9090:

prometheus dashboard

Para verificar si Prometheus realmente está escuchando la aplicación Spring, puede ir al punto final /targets:

monitor prometheus target

Volvamos a la página de inicio, seleccionemos una métrica de la lista y hagamos clic en Ejecutar:

monitor metric from the list

Lenguaje de consulta Prometheus - PromQL

Otra cosa a tener en cuenta es que Prometheus tiene su propio lenguaje de consulta llamado PromQL. Permite al usuario seleccionar y agregar datos de series temporales en tiempo real, almacenándolos en formato gráfico o tabular. Alternativamente, puede enviarlo a una API externa a través de HTTP.

Si desea leer más sobre PromQL, la documentación oficial lo cubre muy bien.

Grafaná

Si bien Prometheus proporciona una visualización cruda, Grafana ofrece una interfaz de usuario enriquecida en la que puede crear gráficos personalizados rápidamente y crear un tablero a partir de muchos gráficos en muy poco tiempo. También puede importar muchos paneles creados por la comunidad de forma gratuita y ponerse en marcha.

Grafana puede extraer datos de varias fuentes de datos como Prometheus, Elasticsearch, InflujoDB, etc. También le permite establezca alertas basadas en reglas, que luego pueden notificarle a través de Slack, correo electrónico, Hipchat y similares.

Comencemos ejecutando Grafana usando Docker:

1
$ docker run -d -p 3000:3000 grafana/grafana

Si visita http://localhost:3000, será redirigido a una página de inicio de sesión:

grafana login page

El nombre de usuario predeterminado es admin y la contraseña predeterminada es admin. Puede cambiarlos en el siguiente paso, que es muy recomendable:

grafana dashboard

Dado que Grafana trabaja con muchas fuentes de datos, debemos definir en cuál nos basamos. Seleccione Prometheus como su fuente de datos:

grafana datasource

Ahora, agregue la URL en la que se ejecuta Prometheus, en nuestro caso http://localhost:9090 y seleccione Acceso para acceder a través de un navegador.

En este punto, podemos guardar y probar para ver si la fuente de datos funciona correctamente:

grafana datasource update

Como se dijo anteriormente, Grafana tiene una tonelada de [tableros] prediseñados (https://grafana.com/grafana/dashboards). Para proyectos Spring Boot, el panel de JVM es popular:

grafana datasource import

Ingrese la URL para el tablero, seleccione "Fuente de datos de Prometheus ya creada" y luego haga clic en Importar:

grafana datasource jvm

Conclusión

Supervisar el estado y las métricas de una aplicación nos ayuda a administrarla mejor, detectar comportamientos no optimizados y comprender mejor su rendimiento. Esto es especialmente cierto cuando estamos desarrollando un sistema con muchos microservicios, donde el monitoreo de cada servicio puede resultar crucial cuando se trata de mantener nuestro sistema.

Basándonos en esta información, podemos sacar conclusiones y decidir qué microservicio necesita escalar si no se pueden lograr más mejoras de rendimiento con la configuración actual.

En este artículo, usamos Micrometer para reformatear los datos de métrica proporcionados por Spring Boot Actuator y exponerlos en un nuevo punto final. Luego, Prometheus, que es una base de datos de series de tiempo, extrajo y almacenó regularmente estos datos. En última instancia, hemos utilizado Grafana para visualizar esta información con un panel de control fácil de usar.

Como siempre, el código de los ejemplos usados ​​en este artículo se puede encontrar en GitHub.