Sin monitorizacion no hay DevOps real. Puedes tener los mejores pipelines de CI/CD y la infraestructura mas elegante, pero si no sabes lo que pasa en produccion en tiempo real, eres reactivo en vez de proactivo. Prometheus y Grafana son el stack de monitorizacion estandar en el mundo Kubernetes y DevOps. En este post te explico como instalarlos y configurarlos desde cero. Si no tienes claro como funcionan los recursos en Kubernetes, repasa antes el post de OOMKilled en Kubernetes.

Que es Prometheus y para que sirve

Prometheus es una herramienta de monitorizacion y alertas de codigo abierto parte de la CNCF. Funciona con un modelo de pull: en vez de que las aplicaciones envien metricas a un servidor central, Prometheus va a buscarlas periodicamente a cada servicio. Consulta la documentacion oficial de Prometheus.

• Metricas: datos numericos con marca de tiempo (CPU, memoria, peticiones por segundo, errores)
• PromQL: lenguaje de consulta para analizar esas metricas
• Alertmanager: gestiona las alertas y las envia a Slack, email, PagerDuty, etc.
• Exporters: agentes que exponen metricas de sistemas externos (node_exporter para Linux, mysqld_exporter para MySQL)

Que es Grafana y para que sirve

Grafana es una plataforma de visualizacion de datos. Se conecta a Prometheus y te permite crear dashboards interactivos con graficas, tablas y alertas visuales. Grafana no almacena metricas, solo las visualiza. Consulta la documentacion oficial de Grafana.

Opcion 1: Instalar con Docker Compose

services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - 9090:9090
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - --config.file=/etc/prometheus/prometheus.yml
      - --storage.tsdb.retention.time=15d
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    ports:
      - 3000:3000
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    ports:
      - 9100:9100
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Archivo prometheus.yml

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: [localhost:9090]

  - job_name: node-exporter
    static_configs:
      - targets: [node-exporter:9100]

  - job_name: mi-app
    static_configs:
      - targets: [mi-app:8080]

docker compose up -d

Prometheus: http://localhost:9090
Grafana: http://localhost:3000 (admin/admin, cambiar en produccion)

Opcion 2: Instalar en Kubernetes con Helm

En Kubernetes la forma recomendada es el kube-prometheus-stack, el chart de Helm que incluye Prometheus, Grafana, Alertmanager y dashboards preconfigurados. Si no tienes claro Helm, revisa el post de Helm charts en Kubernetes.

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

kubectl create namespace monitoring

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set grafana.adminPassword=mi-password-seguro \
  --set prometheus.prometheusSpec.retention=15d

kubectl get pods -n monitoring

NAME                                                   READY   STATUS
alertmanager-kube-prometheus-stack-0                   2/2     Running
kube-prometheus-stack-grafana-xxxx                     3/3     Running
kube-prometheus-stack-prometheus-0                     2/2     Running
kube-prometheus-stack-node-exporter-xxxx               1/1     Running

Acceder a Grafana:
kubectl port-forward -n monitoring svc/kube-prometheus-stack-grafana 3000:80
Grafana en: http://localhost:3000

Consultas PromQL esenciales

PromQL es el lenguaje de consulta de Prometheus. Estas son las consultas que mas usaras en el dia a dia:

Uso de CPU por pod (ultimos 5 minutos):
rate(container_cpu_usage_seconds_total{namespace="default"}[5m])

Uso de memoria por pod:
container_memory_working_set_bytes{namespace="default"}

Porcentaje de uso de memoria respecto al limit:
container_memory_working_set_bytes / kube_pod_container_resource_limits{resource="memory"} * 100

Pods cerca del limite de memoria (alerta cuando supera el 80%):
container_memory_working_set_bytes / kube_pod_container_resource_limits{resource="memory"} > 0.8

Tasa de errores HTTP 5xx:
rate(http_requests_total{status=~"5.."}[5m])

Latencia P99 de una API:
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

Nodos del cluster con mas del 85% de CPU:
100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85

Configurar alertas con Alertmanager

Las alertas se definen en reglas de Prometheus y se envian al Alertmanager, que las enruta a Slack, email u otros destinos:

Regla de alerta para OOMKilled:
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: memoria-alertas
  namespace: monitoring
spec:
  groups:
  - name: memoria
    rules:
    - alert: PodCercaDelLimiteMemoria
      expr: container_memory_working_set_bytes / kube_pod_container_resource_limits{resource="memory"} > 0.85
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: Pod cerca del limite de memoria
        description: El pod ha superado el 85% del limite de memoria durante 5 minutos

    - alert: PodOOMKilled
      expr: kube_pod_container_status_last_terminated_reason{reason="OOMKilled"} == 1
      for: 0m
      labels:
        severity: critical
      annotations:
        summary: Pod terminado por OOMKilled

Dashboards de Grafana listos para importar

Grafana tiene un catalogo de dashboards de la comunidad en grafana.com/grafana/dashboards. Los mas utiles para empezar:

Dashboard	ID	Para que sirve
Kubernetes Cluster Monitoring	315	Vista general del cluster: CPU, memoria, red por nodo
Node Exporter Full	1860	Metricas detalladas de cada nodo Linux
Kubernetes Pod Monitoring	6417	CPU y memoria por pod y namespace
Nginx Ingress Controller	9614	Trafico HTTP, latencia y errores del ingress

Para importarlos: en Grafana ve a Dashboards > Import, pega el ID y selecciona Prometheus como data source.

Exponer metricas desde tu propia aplicacion

Para que Prometheus pueda recoger metricas de tu app, necesita un endpoint /metrics en formato Prometheus. Las librerias cliente existen para todos los lenguajes principales:

Node.js con prom-client:
npm install prom-client

const client = require(prom-client);
client.collectDefaultMetrics();

app.get(/metrics, async (req, res) => {
  res.set(Content-Type, client.register.contentType);
  res.end(await client.register.metrics());
});

Python con prometheus_client:
pip install prometheus_client

from prometheus_client import Counter, start_http_server
peticiones = Counter(http_requests_total, Peticiones HTTP totales)
start_http_server(8080)  # expone /metrics en el puerto 8080

Conclusion

Prometheus y Grafana son el stack de monitorizacion estandar por una razon: son potentes, flexibles y gratuitos. Con kube-prometheus-stack tienes un sistema de monitorizacion completo en Kubernetes listo en 10 minutos. Lo mas importante es empezar a monitorizar — con el tiempo vas afinando las alertas y los dashboards segun lo que tu infraestructura necesite.

Si tienes pods con OOMKilled, ahora tienes las alertas para detectarlos antes de que ocurran — revisa el post de OOMKilled en Kubernetes. Tienes dudas sobre Prometheus o Grafana? Cuentamelo en los comentarios.