Cómo monitorear Kubernetes con Grafana y Prometheus

Monitoreo de Kubernetes con Grafana y Prometheus: Guía Paso a Paso

Monitoreo de Kubernetes con Grafana y Prometheus: Guía Paso a Paso

Kubernetes se ha convertido en la capa fundamental para el despliegue de aplicaciones modernas, pero su naturaleza dinámica y distribuida hace que la observabilidad integral sea un requisito innegociable para el éxito operativo. Necesitas comprender la salud de tus nodos, el rendimiento de tus pods y el estado de tu clúster para garantizar la confiabilidad y evitar costosos tiempos de inactividad. Esta guía te proporciona un camino definitivo y paso a paso para dominar cómo monitorear Kubernetes con Grafana y Prometheus, transformando métricas sin procesar en información procesable que te permita gestionar tu infraestructura de manera proactiva.

Lo que Aprenderás

Al finalizar esta guía, comprenderás cómo implementar un stack de monitoreo completo y listo para producción en tu clúster de Kubernetes utilizando el estándar de la industria kube-prometheus-stack. Podrás conectar Grafana a Prometheus, importar paneles predefinidos para obtener visibilidad inmediata y contar con un plan claro para personalizar alertas y visualizaciones según tus necesidades específicas. El punto más importante es que el chart de Helm kube-prometheus-stack es el método más rápido y confiable para lograr un monitoreo completo de Kubernetes.

El Stack de Monitoreo Estándar de la Industria para Kubernetes

La combinación de Prometheus y Grafana es el estándar de facto para el monitoreo de Kubernetes. Según datos de la industria, se estima que el 75% de las organizaciones que usan Kubernetes adoptan Prometheus y Grafana para sus necesidades de observabilidad. Esto no es solo una tendencia; es un testimonio del poder y la flexibilidad de este conjunto de herramientas de código abierto.

• Prometheus es un proyecto graduado de la Cloud Native Computing Foundation (CNCF) diseñado para ser confiable y escalable. Funciona extrayendo métricas de varios objetivos (como tus pods de aplicación o nodos de Kubernetes) en intervalos específicos y almacenándolas en una base de datos de series temporales. Luego puedes consultar estos datos usando PromQL (Prometheus Query Language), un lenguaje potente y flexible para agregar y analizar métricas.
• Grafana es la capa de visualización. Se integra perfectamente con Prometheus, transformando los datos sin procesar en paneles y gráficos hermosos y en tiempo real. Esta representación visual facilita enormemente la detección de tendencias, anomalías y la resolución de problemas de rendimiento de un vistazo. Grafana también puede servir como una interfaz de usuario unificada para otras fuentes de datos, pero para Kubernetes, Prometheus es su socio más crucial.

Requisitos Previos para tu Configuración

Antes de comenzar, asegúrate de tener las siguientes herramientas instaladas y configuradas. Esta guía asume que tienes un clúster de Kubernetes en funcionamiento, ya sea un entorno de desarrollo local como Minikube o un clúster de producción en la nube.

• Un Clúster de Kubernetes en Ejecución: Necesitas un clúster para implementar el stack de monitoreo. Para pruebas locales, Minikube o Kind funcionan perfectamente.
• Helm: El gestor de paquetes de Kubernetes es esencial para implementar kube-prometheus-stack. Asegúrate de tener Helm v3.2+ instalado en tu máquina local.
• kubectl: La herramienta de línea de comandos de Kubernetes debe estar configurada para comunicarse con tu clúster.

Implementación Paso a Paso: Usando kube-prometheus-stack

La forma más eficiente y recomendada de implementar Prometheus y Grafana para el monitoreo de Kubernetes es usando el chart de Helm kube-prometheus-stack. Este chart es mantenido por la comunidad de Prometheus y agrupa todos los componentes necesarios en un solo paquete fácil de gestionar. Incluye:

• Prometheus Operator: Gestiona las instancias de Prometheus y Alertmanager.
• Prometheus: El servidor de métricas principal.
• Alertmanager: Maneja las alertas enviadas por Prometheus.
• Grafana: La plataforma de visualización.
• Node Exporter: Recopila métricas a nivel de nodo (CPU, memoria, disco) de tus nodos de Kubernetes.
• kube-state-metrics: Genera métricas sobre el estado de los objetos de Kubernetes como pods, deployments y servicios.

1. Agregar el Repositorio de Helm de la Comunidad de Prometheus

Primero, agrega el repositorio oficial de Helm y actualízalo para asegurarte de obtener las últimas versiones del chart.

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

2. Instalar el Stack

Puedes instalar el stack con un solo comando de Helm, personalizándolo con varios parámetros. Este ejemplo crea un namespace monitoring y habilita el almacenamiento persistente para los datos de Prometheus y Grafana.

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.service.type=NodePort \
  --set grafana.service.nodePort=30094 \
  --set grafana.adminPassword=admin \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.accessModes=["ReadWriteOnce"] \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=50Gi \
  --set prometheus.prometheusSpec.retention=30d

• grafana.adminPassword=admin: Establece la contraseña de administrador para Grafana. Cámbiala en producción.
• --set grafana.service.type=NodePort: Expone Grafana fuera del clúster a través de un NodePort para facilitar el acceso.
• prometheus.prometheusSpec.retention=30d: Establece el período de retención de datos de Prometheus en 30 días, esencial para el análisis de tendencias a largo plazo.

3. Verificar la Instalación

Verifica que todos los pods en el namespace monitoring estén en ejecución.

kubectl get pods -n monitoring

La salida debería mostrar varios pods con estado Running, incluyendo los de Grafana, Prometheus, Alertmanager, node-exporter y kube-state-metrics.

Conectando Grafana a tu Fuente de Datos de Prometheus

El chart de Helm kube-prometheus-stack a menudo configura Prometheus como una fuente de datos en Grafana automáticamente. Sin embargo, es mejor verificar la conexión.

Accediendo a la Interfaz de Grafana

Para acceder a la interfaz web de Grafana, puedes usar port-forwarding para pruebas locales o exponer el servicio con un LoadBalancer o Ingress para uso en producción.

Opción A: Port-Forwarding (Para Acceso Local Rápido)

Esta es la forma más sencilla de acceder temporalmente a tu panel.

kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Ahora, abre tu navegador y ve a http://localhost:3000.

⚠️ Importante: El port-forwarding solo es adecuado para pruebas y desarrollo local. Para una configuración permanente en producción, debes exponer Grafana usando un Service de tipo LoadBalancer o un Ingress Controller.

Opción B: LoadBalancer (Recomendado para Entornos en la Nube)

Si estás ejecutando en un proveedor de nube como UpCloud, AWS o GCP, puedes simplemente parchear el servicio de Grafana para usar un LoadBalancer.

kubectl patch svc prometheus-grafana -n monitoring -p '{"spec": {"type": "LoadBalancer"}}'

Luego, obtén la dirección IP externa:

kubectl get svc -n monitoring prometheus-grafana

Accede a Grafana en http://<EXTERNAL-IP>:80.

Iniciando Sesión

Usa las credenciales predeterminadas para iniciar sesión:

• Usuario: admin
• Contraseña: La contraseña que estableciste durante la instalación (por ejemplo, admin o prom-operator).

Una vez iniciada la sesión, navega a Configuration > Data Sources para confirmar que existe una fuente de datos de Prometheus y que funciona. Haz clic en ella y usa el botón Test para asegurar la conectividad.

Creando Paneles: Desde Predefinidos hasta Personalizados

Con Grafana conectado a Prometheus, puedes comenzar a visualizar tus métricas de Kubernetes. La forma más rápida de obtener información valiosa es importar paneles predefinidos de la comunidad de Grafana.

Importando Paneles Predefinidos

Grafana ofrece una amplia biblioteca de paneles comunitarios que puedes importar usando sus IDs únicos.

1. Pasa el cursor sobre el ícono + en la barra lateral y selecciona Import.
2. Ingresa un ID de panel en el campo "Find and import dashboards". Dos paneles altamente recomendados son:
   • 1860: Node Exporter Full – proporciona métricas detalladas sobre los nodos de tu clúster, incluyendo CPU, memoria, disco y red.
   • 8588: Kubernetes Deployment Statefulset Daemonset – ofrece una vista de tus cargas de trabajo de Kubernetes.
3. Haz clic en Load, luego selecciona tu fuente de datos de Prometheus y haz clic en Import.

Estos paneles te darán una vista completa e inmediata de la salud de tu clúster sin necesidad de escribir consultas PromQL.

Creando Paneles Personalizados con PromQL

Si bien los paneles predefinidos son un excelente punto de partida, a menudo necesitarás crear vistas personalizadas adaptadas a tus aplicaciones específicas. Aquí es donde entra PromQL.

Para crear un nuevo panel, haz clic en el ícono + y selecciona New Dashboard. Luego, haz clic en Add visualization y elige tu fuente de datos de Prometheus.

Aquí hay algunas consultas PromQL esenciales para el monitoreo de Kubernetes:

• Uso de CPU por Pod:

  sum(rate(container_cpu_usage_seconds_total{namespace!="kube-system", pod!=""}[5m])) by (pod)

• Uso de Memoria por Pod:

  sum(container_memory_working_set_bytes{namespace!="kube-system", pod!=""}) by (pod) / 1024 / 1024 / 1024

• Estado de Pods por Fase:

  sum(kube_pod_status_phase) by (phase)

  Esta consulta es perfecta para un panel de tipo Stat, permitiéndote ver de un vistazo si todos tus pods están en ejecución.

Configurando Alertas y Notificaciones

El monitoreo es solo la mitad de la batalla; también necesitas ser notificado cuando algo sale mal. Este es el rol de Alertmanager, que está incluido en kube-prometheus-stack.

Configurando Reglas de Alerta

Puedes configurar Alertmanager para enviar notificaciones a varios canales, como Slack, correo electrónico o PagerDuty. Una configuración común y efectiva es enviar alertas a un canal de Slack dedicado.

1. Primero, crea un webhook entrante en tu espacio de trabajo de Slack.
2. Luego, debes modificar la configuración de Alertmanager. Puedes hacerlo proporcionando un archivo values.yaml personalizado durante una actualización de Helm o editando el secreto directamente.
3. Actualiza la sección alertmanager en tu archivo values.yaml con una ruta y un receptor que apunten a la URL de tu webhook de Slack:

alertmanager:
  config:
    route:
      receiver: 'slack-notifications'
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 1h
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/your/webhook/url'
            send_resolved: true
            title: '{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})'
            text: >-
              {{ range .Alerts }}
              *Alerta:* {{ .Labels.alertname }}
              *Severidad:* {{ if .Labels.severity }}{{ .Labels.severity }}{{ else }}n/a{{ end }}
              *Resumen:* {{ if .Annotations.summary }}{{ .Annotations.summary }}{{ else }}n/a{{ end }}
              *Descripción:* {{ if .Annotations.description }}{{ .Annotations.description }}{{ else }}n/a{{ end }}
              {{- end }}

Después de aplicar estos cambios con un helm upgrade, las alertas se enviarán a tu canal de Slack.

Mejores Prácticas para Monitoreo en Producción

Para garantizar que tu stack de monitoreo sea robusto y escalable en un entorno de producción, sigue estas mejores prácticas clave.

• Configura Almacenamiento Persistente: Al implementar en producción, habilita siempre el almacenamiento persistente tanto para Prometheus como para Grafana. Esto asegura que tus datos de métricas y configuraciones de paneles sobrevivan a reinicios de pods y actualizaciones del clúster. En kube-prometheus-stack, esto se controla mediante las configuraciones persistence y storageSpec en el chart de Helm.
• Optimiza el Rendimiento de las Consultas: Las consultas de alta cardinalidad pueden ralentizar tus paneles y el propio Prometheus. Para mantener el rendimiento, agrega siempre tus consultas PromQL en la fuente. Por ejemplo, en lugar de consultar container_cpu_usage_seconds_total, agrégalo por namespace: sum by (namespace) (rate(container_cpu_usage_seconds_total[5m])). Esto reduce la cantidad de datos que Grafana necesita procesar.
• Establece Períodos de Retención Adecuados: El período de retención predeterminado de Prometheus es de 15 días. Ajústalo según tus necesidades. Un período de retención más largo (por ejemplo, 30-60 días) es útil para el análisis de tendencias a largo plazo, pero requerirá más espacio de almacenamiento.
• Gestiona la Configuración como Código: A medida que tus necesidades de monitoreo evolucionen, probablemente personalizarás paneles y reglas de alerta. Exporta tus paneles como JSON y guárdalos en control de versiones (por ejemplo, Git) junto con tus reglas de alerta. Esta práctica, conocida como GitOps, hace que tu configuración de monitoreo sea reproducible y auditable.
• Ajusta los Intervalos de Extracción: El intervalo de extracción predeterminado para Prometheus es de 30 segundos. Para métricas críticas de alta velocidad, es posible que desees extraer con más frecuencia, pero ten en cuenta que esto aumenta la carga en Prometheus y en el servidor API de tu clúster. Puedes personalizar estos intervalos en los valores de Helm.

Preguntas Frecuentes

1. ¿Cuál es la forma más fácil de monitorear Kubernetes con Grafana y Prometheus? El método más fácil y recomendado es usar el chart de Helm kube-prometheus-stack. Agrupa Prometheus, Grafana, Alertmanager, node-exporter y kube-state-metrics en un solo paquete, y puedes implementarlo con solo unos pocos comandos.

2. ¿Es necesario usar kube-state-metrics para monitorear Kubernetes? Sí, kube-state-metrics es un componente crítico que genera métricas sobre el estado de tus objetos de Kubernetes, como la cantidad de pods listos o el estado de un deployment. Sin él, no tendrías visibilidad sobre la salud de tus recursos de Kubernetes de nivel superior.

3. ¿Cómo puedo hacer que mis paneles de Kubernetes se carguen más rápido? Los paneles lentos a menudo son causados por consultas PromQL ineficientes. Una solución clave es agregar tus consultas para reducir la cardinalidad. Por ejemplo, en lugar de mostrar datos para cada pod, resúmelos a nivel de namespace usando consultas como sum by (namespace) (rate(...)).

4. ¿Cuál es la mejor manera de recibir alertas de mi monitoreo de Kubernetes? Prometheus funciona con Alertmanager, que puede enviar notificaciones a varios canales. Un método popular y simple es configurar Alertmanager para enviar alertas a un canal de Slack a través de un webhook entrante. Esto proporciona notificaciones en tiempo real y procesables.

5. ¿Necesito instalar Node Exporter manualmente en cada nodo? No. Cuando implementas el chart de Helm kube-prometheus-stack, automáticamente despliega un DaemonSet de Node Exporter. Esto asegura que un pod de Node Exporter se ejecute en cada nodo de tu clúster, permitiendo que Prometheus recopile métricas a nivel de nodo como CPU, memoria y uso de disco sin intervención manual.

Fuentes

1. UpCloud Global. (2025). Monitoring on UpCloud with Prometheus: Part 3.
2. Ubuntu Documentation. (2026). How to use Prometheus with Canonical Kubernetes.
3. Sfeir Institute. (2026). Create Effective Grafana Dashboards for Kubernetes Monitoring.
4. Ory. (2025). Monitoring.
5. GitHub - AkramGalal. (2025). deploying-prometheus-grafana-K8s-using-helm.
6. Go Packages. (2025). kube-prometheus.
7. GitHub - dotdc. (2026). grafana-dashboards-kubernetes.
8. Scaleway. (2025). Kubernetes Kapsule cluster monitoring with Prometheus & Grafana.
9. Mirantis. (2025). How to Set Up Prometheus & Grafana in K8s with Alertmanager & Slack Alerts.
10. Microsoft Learn. (2025). Using ConfigMap to customize Prometheus metric collection in Azure Monitor.
11. GitHub - Rurutia1027. (2025). Hands-on-Lab.K8s-Monitoring.

— Editorial Team