Admin-Sistemas ·

Implementación de métricas de latencia de microservicios con Prometheus y OpenTelemetry

Introducción

En entornos de microservicios, la latencia es uno de los indicadores críticos para identificar cuellos de botella que pueden afectar la experiencia del usuario. Herramientas como Prometheus y OpenTelemetry permiten recolectar métricas de forma estandarizada y exportarlas a sistemas de visualización como Grafana.

Este artículo muestra, con ejemplos reales, cómo crear métricas personalizadas de latencia, exponerlas mediante un endpoint /metrics y configurarlas en Prometheus para alertas proactivas.

1. Preparación del entorno

1.1 Requisitos previos

  • Cluster Kubernetes (minikube, kind o un clúster real).
  • Helm 3 instalado.
  • Lenguaje de desarrollo con soporte OpenTelemetry (ejemplo: Go, Java o Python).
  • Acceso a kubectl y helm.

1.2 Instalación de Prometheus y Grafana con Helm

# Añadir repositorio de kube‑prometheus‑stack
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

Desplegar el stack (incluye Prometheus, Alertmanager y Grafana)

helm install monitoring prometheus-community/kube-prometheus-stack
—namespace monitoring —create-namespace
—set grafana.adminPassword=‘admin123’
—set prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues=false

Una vez completado, verifica los pods:

kubectl get pods -n monitoring

2. Instrumentación de microservicios con OpenTelemetry

2.1 Añadir dependencias

Ejemplo con Go:

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/sdk/metric
go get go.opentelemetry.io/otel/exporters/prometheus

2.2 Crear un medidor de latencia personalizado

Definimos una métrica del tipo Histogram para capturar la distribución de tiempos de respuesta.

package main

import ( “context” “log” “net/http” “time”

"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/metric/global"
"go.opentelemetry.io/otel/exporters/prometheus"
"go.opentelemetry.io/otel/sdk/metric/controller/basic"
"go.opentelemetry.io/otel/sdk/metric/selector/simple"

)

func main() { // 1. Configurar exporter Prometheus exporter, err := prometheus.New() if err != nil { log.Fatalf(“failed to create prometheus exporter: %v”, err) }

// 2. Crear controlador de métricas
cont := basic.New(
    simple.NewWithExactDistribution(),
    exporter,
)
if err := cont.Start(context.Background()); err != nil {
    log.Fatalf("could not start metric controller: %v", err)
}
// Registramos el controlador global
global.SetMeterProvider(cont)

// 3. Definir el medidor
meter := otel.Meter("my.microservice")
latencyHist, err := meter.Float64Histogram(
    "http_server_request_duration_seconds",
    metric.WithDescription("Latencia de respuestas HTTP del microservicio"),
    metric.WithUnit("seconds"),
)
if err != nil {
    log.Fatalf("cannot create histogram: %v", err)
}

// 4. Handler que mide latencia
handler := func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    // Simular procesamiento
    time.Sleep(time.Duration(100+rand.Intn(200)) * time.Millisecond)
    w.Write([]byte("OK"))
    // Registrar la latencia
    latencyHist.Record(r.Context(), time.Since(start).Seconds(),
        // Etiquetas útiles
        attribute.String("method", r.Method),
        attribute.String("route", r.URL.Path),
        attribute.String("service", "order-service"),
    )
}

// 5. Exponer /metrics para Prometheus
http.Handle("/metrics", exporter)
http.HandleFunc("/", handler)

log.Println("Listening on