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
kubectlyhelm.
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 updateDesplegar 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