Introducción a la Ingeniería de Datos con Grafana y Docker

Introducción

En el entorno del comercio electrónico, donde se procesan miles de transacciones por segundo, garantizar el buen rendimiento del sistema es crucial. Un pipeline de datos procesa estas transacciones y asegura que la información fluya sin interrupciones desde las bases de datos hasta las aplicaciones.

Para asegurar que los sistemas estén operando eficientemente, es fundamental monitorear métricas clave de rendimiento, como la Tasa de Transacciones por Segundo (TPS), el uso de CPU, y la memoria utilizada. En este artículo, veremos cómo integrar Python, SQL, Prometheus PushGateway y Grafana usando Docker, para recopilar, procesar y visualizar métricas en tiempo real.

Paso 1: Configuración de la Base de Datos MySQL con Docker

1.1 Comando para ejecutar MySQL en Docker

Empezamos ejecutando un contenedor MySQL con Docker para almacenar las transacciones:

docker run --name mysql-db -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=transactions -p 3306:3306 -d mysql:latest

Seguridad: En un entorno de producción, se recomienda usar variables de entorno o un gestor de contraseñas en lugar de pasar la contraseña directamente en el comando.

1.2 Crear la Tabla de Transacciones

Creamos una tabla básica para almacenar transacciones ficticias:

CREATE TABLE transactions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT,
    product_id INT,
    amount DECIMAL(10, 2),
    status VARCHAR(20),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Insertamos datos ficticios para simular las transacciones:

INSERT INTO transactions (user_id, product_id, amount, status) 
VALUES (1, 101, 99.99, 'completed'), 
       (2, 102, 45.50, 'pending'), 
       (3, 103, 150.00, 'failed');

Paso 2: Procesar los Datos con Python

2.1 Instalación de Dependencias

Instalamos las bibliotecas necesarias para conectar Python con MySQL y manejar los datos:

pip install mysql-connector-python pandas prometheus_client

2.2 Extraer Transacciones y Calcular la TPS

El siguiente script Python conecta a la base de datos MySQL, extrae las transacciones completadas y calcula estadísticas de la TPS (Tasa de Transacciones por Segundo). También exponemos estas métricas a Prometheus PushGateway para que puedan ser monitorizadas por Grafana.

Código Python mejorado:

import mysql.connector
import pandas as pd
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway
import time

def get_transactions_data():
    try:
        # Conexión a MySQL
        conn = mysql.connector.connect(
            host="localhost",
            user="root",
            password="secret",
            database="transactions"
        )
        cursor = conn.cursor()

        # Consultar transacciones completadas
        query = "SELECT created_at FROM transactions WHERE status = 'completed';"
        cursor.execute(query)

        # Obtener resultados y convertir a DataFrame
        result = cursor.fetchall()
        df = pd.DataFrame(result, columns=['created_at'])

        # Calcular la tasa de transacciones por segundo (TPS)
        df['created_at'] = pd.to_datetime(df['created_at'])
        df = df.set_index('created_at').resample('S').size()

        # Calcular estadísticas de TPS
        tps_avg = df.mean()
        tps_min = df.min()
        tps_max = df.max()

        print(f"TPS promedio: {tps_avg:.2f}, TPS mínima: {tps_min}, TPS máxima: {tps_max}")

        # Exponer métricas de TPS a Prometheus PushGateway
        registry = CollectorRegistry()
        g = Gauge('transactions_per_second', 'TPS en tiempo real', registry=registry)
        g.set(tps_avg)
        push_to_gateway('localhost:9091', job='transaction_job', registry=registry)

    except mysql.connector.Error as err:
        print(f"Error: {err}")

    finally:
        cursor.close()
        conn.close()

# Ejecutar función
get_transactions_data()

Explicación del Código:

• Cálculo de la TPS: El script calcula las estadísticas de TPS (promedio, mínimo y máximo) utilizando pandas y las imprime en la consola.
• Prometheus PushGateway: Usamos prometheus_client para enviar las métricas de TPS al PushGateway de Prometheus, que las expone a Prometheus.
• pdb para depuración: Si necesitas depurar, añade import pdb; pdb.set_trace() en cualquier parte del código.

Paso 3: Monitoreo del Sistema con Prometheus y Grafana

3.1 ¿Qué es Prometheus PushGateway?

Prometheus PushGateway permite a aplicaciones como Python enviar métricas personalizadas (como la TPS) a Prometheus. Esto es útil para trabajos que no están en ejecución continua pero necesitan enviar métricas a intervalos irregulares.

Configuración de Prometheus PushGateway con Docker:

docker run -d --name pushgateway -p 9091:9091 prom/pushgateway

3.2 Instalación de Prometheus y Grafana usando Docker

Iniciamos contenedores para Prometheus y Grafana:

# Ejecutar Prometheus
docker run -d --name prometheus -p 9090:9090 prom/prometheus

# Ejecutar Grafana
docker run -d --name=grafana -p 3000:3000 grafana/grafana

Accede a Grafana en http://localhost:3000 (credenciales: admin/admin).

3.3 Añadir Prometheus como Fuente de Datos en Grafana

1. Inicia sesión en Grafana.
2. Ve a Configuration > Data Sources.
3. Añade una nueva fuente de datos y selecciona Prometheus.
4. Introduce la URL de Prometheus (http://localhost:9090).
5. Haz clic en Save & Test.

3.4 Consultas de Prometheus para Monitoreo

Consulta para monitorear TPS desde PushGateway:

Esta consulta devuelve el valor de TPS expuesto por el PushGateway de Prometheus.

Consulta para monitorear el uso de memoria de Docker:

Paso 4: Creación de un Dashboard en Grafana

Ahora crearemos un dashboard en Grafana para visualizar las métricas de TPS y uso de memoria.

4.1 Visualizar el uso de memoria:

1. Ve a Dashboards > New Dashboard.
2. Añade un nuevo panel y selecciona la consulta de Prometheus para monitorear el uso de memoria del contenedor MySQL:

4.2 Visualizar la TPS desde PushGateway:

1. Crea un nuevo panel en el mismo dashboard.
2. Usa la consulta transactions_per_second para visualizar la TPS en tiempo real.

Escalabilidad y Rendimiento

Escalar con Docker

Para escalar el sistema, se pueden ejecutar múltiples instancias de MySQL o cualquier otro servicio, y distribuir la carga utilizando balanceadores de carga como NGINX o HAProxy.

Verificar contenedores en ejecución:

docker ps

Este comando muestra todos los contenedores activos. También puedes revisar los logs con:

docker logs <container_name>

Manejo de la Carga en Prometheus

Prometheus puede manejar grandes volúmenes de datos distribuyendo la carga en varios scrapers y almacenando datos de series temporales en discos rápidos como SSD.

Conclusión

La ingeniería de datos no solo consiste en mover y procesar información, sino también en asegurar que los sistemas operen de manera eficiente. Con esta integración de Python, Prometheus PushGateway y Grafana usando Docker, hemos creado un sistema completo para monitorizar la TPS y el uso de recursos en tiempo real.

Con estas herramientas, puedes optimizar el rendimiento de los sistemas y detectar problemas antes de que afecten las operaciones críticas. Además, la escalabilidad está garantizada al utilizar contenedores Docker, que facilitan el despliegue de múltiples instancias y la distribución de carga.

Próximos pasos:

1. Configurar alertas automáticas en Grafana para recibir notificaciones cuando la TPS o el uso de memoria superen los límites establecidos.
2. Expandir el monitoreo con más métricas personalizadas.