Mostrando entradas con la etiqueta trazabilidad. Mostrar todas las entradas
Mostrando entradas con la etiqueta trazabilidad. Mostrar todas las entradas

lunes, 11 de octubre de 2021

Apache Camel: Control de Trazas con Zipkin

Hoy vamos a ver posiblemente uno de los post más sencillos que hemos hecho de Apache Camel. En el veremos como integrarlo con Zipkin. 

Zipkin es una herramienta distribuida de instrumentación y monitorización que nos permitirá recopilar información de servicios y realizar búsquedas sobre la misma. Con el objetivo de hallar problemas en la latencia de los mismos, a través principalmente de evaluar cuanto tiempo ha tardado en la ejecución del servicio. 

Ya vimos hace tiempo un ejemplo de Apache Camel con Jaeger, aquí. Y esta es otra herramienta pero con un objetivo similar. Por lo que nos servirá refrescar conceptos que vimos en el anterior post:

  • Distributed Tracing: Es un método utilizado para perfilar y supervisar las aplicaciones. Nos ayuda a señalar dónde ocurren los fallos y qué es lo que causa el mal funcionamiento.
  • Span: Es el principal componente de una traza distribuida, que representa una unidad individual de trabajo realizada en un sistema distribuido. Estos encapsulan información de la aplicación.
  • Traza: Es un gráfico acíclico de Span. 

Camel Zipkin es un componente que nos permitirá rastrear los mensajes de entrada y salida a Camel y su tiempo asociado. Los span serán capturado y enviados a Zipkin. 

Uno de los puntos importantes, es que se cree un mapeo de los endpoints de Apache Camel para que se pueda realizar mejores búsquedas en Zipkin. Asociando cada span a un servicio concreto y no a toda la aplicación. 

El mapeo de los servicios se puede realizar con el uso de wildcards o expresiones regulares. Si no se indica nada, Camel mandará por defecto la URL de las invocaciones. 

Pero empecemos con el ejemplo, el cual podremos ver en marcha facilmente. El primer paso será levantar un docker con zipkin. Lo cual podemos hacer en una sola linea. 

docker run -d -p 9411:9411 openzipkin/zipkin

Y el siguiente paso será configurar nuestra aplicación. Como efecto diferenciador a cualquier otra aplicación de Apache camel tendremos que añadir la dependencia para hacer uso de Zipkin. Como nosotros utilizamos Apache Camel con Spring, solo necesitaremos el starter. 

<dependency>
	<groupId>org.apache.camel.springboot</groupId>
	<artifactId>camel-zipkin-starter</artifactId>
</dependency>

Lo siguiente será configurar la aplicación para el envío de información a Zipkin a través de la anotación @CamelZipkin que pondremos en la clase principal de arranque. Y en el fichero de configuración indicaremos la URL donde se enviarán los spans.

camel.zipkin.endpoint=http://localhost:9411/api/v2/spans

Ahora ya podremos realizar invocaciones a los métodos de nuestros servicios y veremos dichas invocaciones en la interfaz gráfica de Zipkin. 


Como se puede apreciar en la captura, se indica el tiempo de ejecución de ejecución del método. Pero como no hemos configurado nada, vemos simplemente la URL de la invocación que hemos hecho. 

Si pulsamos en el botón show, podremos ver más detalle del span, las etiquetas asociadas y la traza asociada a la misma. 


La información que vemos es un poco escueta, porque no hemos realizado ningún tipo de configuración ni mapeo de los servicios. A continuación veremos como podemos personalizar la medición de las invocaciones a los métodos. 

En el fichero application.properties podemos indicar dos tipos de configuración. Son incompatibles, si se marca el mapeo individual, los servicios que nos se encuentren mapeados no se enviarán a zipkin. 

  • camel.zipkin.service-name: Nos permite indicar un nombre para el mapeo de todos los servicios de la aplicación y que no se muestre únicamente la URL. 
  • camel.zipkin.server-service-mappings.{serviceId}: Nos permite indicar un mapeo específico a un servicio concreto. Este servicio se puede identificar por el routeId del mismo en Camel. 
Si indicamos la siguiente configuración, tendremos la salida que mostramos más abajo. 

camel.zipkin.server-service-mappings.mockClientGetAll=getAll
camel.zipkin.server-service-mappings.mockGetById=getById


Como veis, ha sido realmente sencillo comunicar nuestros servicios de Apache Camel con una plataforma tan útil como Zipkin e instrumentalizar y monitorizar el funcionamiento de vuestros micro-servicios. 

Como siempre todo el código podéis verlo aquí

viernes, 30 de octubre de 2020

Apache Camel: Control de trazas con Jaeger

 Hoy vamos a ampliar nuestro ejemplo de Apache Camel y vamos a incluir Jaeger. Pero antes de ver como debemos hacerlo, explicaremos un poco que es OpenTraicing y Jaeger. 

OpenTracing es, como ellos mismos se definen, una APIs e instrumentación para el rastreo distribuido, neutrales en cuanto a los proveedores. Y aunque la creo Uber ahora es open-source y tiene importantes compañías detrás.

OpenTracing quiere formar un lenguaje común en torno a lo que es una traza y cómo manejarla en nuestras aplicaciones. Y para entender su funcionamiento debemos entender antes varios conceptos:

  • Distributed Tracing: Es un método utilizado para perfilar y supervisar las aplicaciones. Nos ayuda a señalar dónde ocurren los fallos y qué es lo que causa el mal funcionamiento.
  • Span: Es el principal componente de una traza distribuida, que representa una unidad individual de trabajo realizada en un sistema distribuido. Estos encapsulan información de la aplicación.
  • Traza: Es un gráfico acíclico de Span. 
  • Tracer: Es la implementación de la API que recolectará los Span y los publicará.

Una traza se podría representar así:

Y si tenemos en cuenta el tiempo, con este otro gráfico:

Sabiendo esto, ya nos quedará más claro cuando digamos que Jaeger será un Tracer que nos permitirá recolectar la información de las trazas de nuestra aplicación y visualizarlas en un interfaz gráfica propia. 

Con lo cual ya podremos incorporar Jaeger a nuestro docker compose con la siguiente instrucción:

jaeger:
image: jaegertracing/all-in-one:latest
ports:
- "6831:6831"
- "16686:16686"

Una vez arranquemos, ya podremos acceder a su interfaz gráfica a través de la URL http://localhost:16686

Una vez que lo tenemos preparado, vamos a configurar nuestra aplicación. Esto lo podemos hacer con tres sencillos pasos:

  • Añadir la librería camel-opentracing-starter. El cual nos auto configurará nuestra aplicación Spring Boot para el uso de Open Tracing
  • Añadir la anotación @CamelOpenTracing en la clase principal. La cual habilitará el uso de Open Tracing. 
  • Añadir una implementación de OpenTracing, en este caso la Jaeger. A través de la librería io.jaegertracing:jaeger-client.
Además hay que crear la variable de entorno JAEGER_SERVICE_NAME para indicar de qué aplicación se  recopilan los datos.

Para ver mejor el ejemplo, vamos a probar dos métodos uno con JPA y otro de una versión anterior que usa el componente SQL. Realizaremos varias llamadas y posteriormente accederemos a Jaeger. A través de la UI seleccionaremos nuestra aplicación en el campo Service y pulsaremos el botón Search. En ese momento Jaeger nos mostrará cuales son llamadas que hemos realizado. 


Si seleccionamos alguna de las invocaciones, veremos con más detalles las partes de la misma. En este caso al ser métodos muy básicos, la traza es muy sencilla. 


Incluso puede seleccionar varias trazas y compararlas con un simple click:


Como podemos apreciar de una forma sencilla podemos recoger importante información sobre la aplicación. Esta información nos puede ayudar a por ejemplo a depurar el funcionamiento de un micro servicio y ver qué partes del mismo son un posible cuello de botella.