Monitoreo y pruebas Hyperledger Fabric con Prometheus y Caliper

Hyperledger Caliper es una herramienta que nos permite realizar comparativas de rendimiento o benchmarks de una red blockchain a partir de una serie de casos de usos definidos. Esta tiene la capacidad de generar reportes con una serie de métricas e indicadores que pueden servir como factores claves para reconocer patrones y posibles fallos en la implementación.

Hyperledger Caliper es compatible con las siguientes soluciones blockchain:

• Hyperledger Besu.
• Burrow.
• Ethereum.
• Hyperledger Fabric.
• FISCO BCOS.
• Hyperledger Iroha.
• Hyperledger Sawtooth.

Prometheus es una herramienta Open Source para el monitoreo de sistemas, este recolecta métricas de distintos “canales” en intervalos de tiempo parametrizables, permite crear expresiones para evaluar métricas, presenta los resultados de manera clara y puede activar alertas si ciertas condiciones se alcanzan.

Antes de comenzar, quiero agradecer a las personas pertenecientes a esta iniciativa — Juan Pablo Ramírez Herrera, Mauricio Serna Flórez y Bram Dufour quienes con su conocimiento hicieron posible la realización de este artículo.

Básicamente, para la configuración de las pruebas y monitoreo, se llevaron a cabo los siguientes pasos:

Despliegue de red Blockchain

Usaremos una red basada en HyperLedger Fabric, como este artículo no se centra en su creación, te presentamos 2 links muy valiosos a continuación:

Para conocer los componentes de la red y una pequeña introducción a Blockchain, este artículo puede interesarte.

Blockchain, Hyperledger Fabric. ¿Es realmente interesante esta tecnología para Bancolombia?

Para el despliegue de una red de pruebas, puedes usar la documentación de Hyperledger.

Si quieres usar métricas propias de un Peer o un Orderer especialmente diseñadas para ser consumidas por Prometheus, no olvides activar los Servicios de Operaciones, si usas la red de prueba BYFN es necesario que modifiques la sección Operations en el archivo core.yaml especificando el listenAddress y las configuraciones TLS(para pruebas locales, simplemente deja el TLS deshabilitado)

Operations:
  # host and port for the operations server
  ListenAddress: 127.0.0.1:8443
  # TLS configuration for the operations endpoint
  TLS:
    # TLS enabled
    Enabled: false    
    # Certificate is the location of the PEM encoded TLS certificate
    Certificate:
    # PrivateKey points to the location of the PEM-encoded key
    PrivateKey:
    # Most operations service endpoints require client  authentication when TLS
    # is enabled. ClientAuthRequired requires client certificate authentication
    # at the TLS layer to access all resources.
    ClientAuthRequired: false

Para contar con las métricas, debemos modificar la sección de métricas agregando Prometheus como provider.

###############################################################################
#
# Metrics section
#
###############################################################################
metrics:
# metrics provider is one of statsd, prometheus, or disabled
provider: prometheus

Integración Caliper

Caliper puede usarse como un paquete alojado en NPM, @hyperledger/caliper-cli , dentro de la carpeta de tu nuevo proyecto, lo puedes instalar así:

npm init -y
npm install --only=prod @hyperledger/caliper-cli@0.3.2

Para el uso adecuado de Caliper, debemos agregar 1 paso de configuración extra con el comando bind. Este comando simplemente instala algunos paquetes necesarios y realiza algunas configuraciones de instalación, usaremos los parámetros:

• SUT/nombre de plataforma: Especificación del nombre de la plataforma que usaremos, en nuestro caso Fabric.
• Versión SDK : Version del SDK que vamos a usar.

Nuestro comando quedará así:

npx caliper bind --caliper-bind-sut fabric:2.1.0 --caliper-bind-sdk 2.1.0 --caliper-fabric-gateway-usegateway --caliper-flow-only-test

caliper-flow-only-test Solo ejecuta las pruebas del benchmark definido.

caliper-fabric-gateway-usegateway A partir de la versión 2.0 del SDK, solo se soportan operaciones a través de un gateway, para el caso es necesario especificarlo, si usas una versión anterior (1.14 por ejemplo) no es necesario que lo especifiques.

Para la ejecución de las pruebas, también debemos configurar un comando con los siguientes parámetros:

• Espacio de trabajo: El directorio que servirá como la raíz de tu proyecto
• Archivo de configuración de las pruebas: El archivo que contiene la configuración para la ejecución de tu prueba, es necesario que este archivo exista dentro del workspace que definiste.
• Archivo de configuración para la red: Este archivo contiene la configuración de la red a la que vas a conectarte, es necesario que este archivo exista dentro del workspace que definiste.
• Workers: Si tu objetivo es realizar pruebas distribuidas, en distintas máquinas, puedes usar los parámetros caliper-worker-remote true , por defecto este valor es false , los workers necesarios se desplegarán localmente. Puedes usar caliper-worker-communication-method si quieres comunicarte a tus workers remotos, a través de mqtt.

Nuestro comando quedará así:

npx caliper launch master --caliper-workspace . --caliper-benchconfig benchmarks/test-fixed-rate.yaml --caliper-networkconfig networks/local.yaml

Profundizaremos en 2 archivos, la configuración de la prueba y la configuración de la red.

Para la configuración de la prueba, usamos un archivo como este:

La prueba tendrá un nombre, una cantidad de workers, en este caso 4, que se ejecutarán localmente, en la primera ronda, usaremos pruebas con valor fijo, 500 transacciones a un paso de 20 por segundo. Si necesitamos enviar parámetros en nuestra prueba, dentro de la sección arguments podremos enviarlos; para el callback de la función, crearemos un archivo javascript con la configuración de nuestra prueba. Este archivo debe contener tu invocación del chaincode y las acciones que deseas ejecutar.

Para usar Prometheus como nuestro monitor, agregaremos los siguientes parámetros en el archivo.

El monitor nos servirá de manera correcta con Prometheus, url y push_url son direcciones que veremos más adelante con los servicios que Prometheus nos provee.

Si quieres agregar métricas distintas o procesar alguna antes de obtener el resultado, puedes agregar el parámetro metrics y crear tus propias métricas.

Para nuestra red, usaremos un archivo de configuración similar al siguiente:

Primero, definiremos las generalidades, usaremos fabric como solución, especificaremos el tamaño de nuestra red, el tipo del orderer, la forma de distribución y la base de datos que mantiene nuestro estado. En la sección clientes, configuraremos los datos necesarios para que un cliente pueda conectarse a la red, su nombre, la organización a la que pertenece, el almacenamiento de sus credenciales, etc. No iremos a la profundidad del cliente pues esto es algo especifico para cada implementación.

En la siguiente sección agregaremos la información del canal, de los peers, y del chaincode que usaremos.

Con los pasos anteriores, tendremos el esquema básico para la ejecución de pruebas.

Integración Prometheus

Para desplegar Prometheus, usaremos docker-compose con los distintos componentes que nos permiten realizar mediciones, estos componentes pueden resumirse así:

• Prometheus: Servicio principal que presenta la interfaz, viene con una configuración por defecto
• PushGateway: Servicio intermedio que permite exponer métricas a Prometheus a través de tareas.
• Node-exporter: Servicio intermedio para obtención de métricas de hardware y sistema operativo.
• cAdvisor: Servicio intermedio para obtención de métricas relacionadas a un contenedor.

Para nuestro caso, usaremos PushGateway, si quisiéramos realizar el proceso con node-exporter o cAdvisor, podríamos agregar una tarea para tomar las métricas de estos servicios.

Nuestro docker compose, levantará los servicios que necesitemos, agregando los volúmenes necesarios para almacenar la información:

version: '3'
volumes:
prometheus_data: {}
services:
prometheus:
image: prom/prometheus
container_name: prometheus
volumes:
- ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus_data:/prometheus
command:
- '--config.file=/etc/prometheus/prometheus.yml'
- '--storage.tsdb.path=/prometheus'
- '--web.console.libraries=/usr/share/prometheus/console_libraries'
- '--web.console.templates=/usr/share/prometheus/consoles'
ports:
- "9090:9090"
pushGateway:
image: prom/pushgateway
container_name: pushGateway
ports:
- "9091:9091"
node-exporter:
image: prom/node-exporter
container_name: node-exporter
volumes:
- /proc:/host/proc:ro
- /sys:/host/sys:ro
command:
- '--path.procfs=/host/proc'
- '--path.sysfs=/host/sys'
- --collector.filesystem.ignored-mount-points
- "^/(sys|proc|dev|host|etc|rootfs/var/lib/docker/containers|rootfs/var/lib/docker/overlay2|rootfs/run/docker/netns|rootfs/var/lib/docker/aufs)($$|/)"
ports:
- 9100:9100
cadvisor:
image: google/cadvisor:v0.27.4
privileged: true
container_name: cadvisor
volumes:
- /var/run:/var/run:rw
- /sys:/sys:ro
- /var/lib/docker/:/var/lib/docker:ro
ports:
- 8080:8080
restart: always

Encontrarás en este yaml, una línea que busca un archivo de configuración, prometheus.yml, agrégalo a tu proyecto, en este, agregaremos todas las tareas de las cuales obtendremos métricas y la configuración de Prometheus.

global:
scrape_interval: 1s
external_labels:
monitor: ‘devopsage-monitor’
scrape_configs:
- job_name: ‘prometheus’
# Retain labels, as within PushGateway use
honor_labels: true
static_configs:
- targets: [‘prometheus:9090’, ‘pushGateway:9091’]
- job_name: containers
scrape_interval: 5s
static_configs:
- targets: [‘cadvisor:8080’]
- job_name: orderer
static_configs:
- targets: [‘orderer.org0.com:8443’]
labels:
instance: localhost

Generamos distintas tareas para cada una de las métricas, la tarea prometheus recoge métricas de Prometheus y métricas del servicio PushGateway, donde recolectamos métricas propias de la ejecución de Caliper, como las transacciones por segundo. Agregamos una tarea extra llamada containers para ejemplificar el monitoreo de las métricas del cAdvisor, también, agregamos una tarea orderer para ejemplificar la toma de métricas propias de este componente de la red.

Cada tarea se identifica con un job name, se agregaron también sus configuraciones internas, periodicidad de toma de muestras, los componentes que nos entregarán las métricas

Lo que debes hacer a continuación, es ejecutar el comando docker-compose -f <nombre del archivo> up, si todo ha sido exitoso, podrás observar el dashboard de Prometheus ingresando desde tu navegador a localhost:9090

Dashboard local

Para revisar si tus tareas están sanas, selecciona Status -> targets, allí encontraras cuáles tareas están corriendo de manera correcta y cuáles presentan algún inconveniente.

Cuando ejecutes tus pruebas con Caliper, si ingresas a localhost:9091, encontrarás métricas del PushGateway, allí encontrarás los resultados de las pruebas, etiquetados por tipo de prueba, ronda y tarea.