← Volver al listado de tecnologías ← Índice de K3s

Capitulo 14: Monitoring con Prometheus y Grafana

1 de marzo de 2026 Por: Artiko

k3skubernetesprometheusgrafanamonitoring

Capitulo 14: Monitoring con Prometheus y Grafana

Por que Monitorear

Un cluster de Kubernetes sin monitoring es como conducir sin tablero de instrumentos. No sabes cuanta CPU consumen tus pods, si un nodo esta al limite de memoria o si un servicio empezo a fallar hace una hora.

El monitoring te da:

Visibilidad: metricas en tiempo real de nodos, pods y servicios
Deteccion temprana: alertas antes de que los usuarios noten problemas
Planificacion de capacidad: datos historicos para decidir cuando escalar
Debugging: correlacionar picos de recursos con incidentes

Stack de Monitoring

El stack estandar de la industria para Kubernetes es:

Prometheus: recolecta y almacena metricas como series de tiempo
Grafana: visualiza las metricas en dashboards interactivos
Alertmanager: gestiona alertas y las envia por email, Slack u otros canales

El chart kube-prometheus-stack instala los tres componentes junto con exporters y dashboards preconfigurados.

Instalar kube-prometheus-stack

Usa Helm para instalar todo el stack:

# Agregar repositorio
helm repo add prometheus-community \
  https://prometheus-community.github.io/helm-charts
helm repo update

# Crear namespace dedicado
kubectl create namespace monitoring

# Instalar el stack
helm install kube-prometheus \
  prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  -f monitoring-values.yaml

Archivo de valores recomendado para K3s:

# monitoring-values.yaml
prometheus:
  prometheusSpec:
    retention: 7d
    resources:
      requests:
        cpu: 200m
        memory: 512Mi
      limits:
        cpu: 500m
        memory: 1Gi
    storageSpec:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 10Gi

grafana:
  adminPassword: "tu-password-seguro"
  resources:
    requests:
      cpu: 100m
      memory: 128Mi
    limits:
      cpu: 200m
      memory: 256Mi

alertmanager:
  alertmanagerSpec:
    resources:
      requests:
        cpu: 50m
        memory: 64Mi
      limits:
        cpu: 100m
        memory: 128Mi

Verifica que todos los pods esten corriendo:

kubectl get pods -n monitoring

Como Funciona Prometheus

Prometheus usa un modelo de pull (scraping). En lugar de que las aplicaciones envien metricas, Prometheus las recolecta periodicamente de endpoints HTTP.

Scraping

Cada aplicacion expone un endpoint /metrics que Prometheus consulta a intervalos regulares (por defecto 30 segundos). El endpoint devuelve metricas en formato texto plano.

ServiceMonitor

El operador de Prometheus usa recursos ServiceMonitor para descubrir que servicios debe scrapear:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: mi-app-monitor
  namespace: monitoring
spec:
  selector:
    matchLabels:
      app: mi-app
  endpoints:
    - port: metrics
      interval: 15s
      path: /metrics

Esto le dice a Prometheus: “busca Services con el label app: mi-app y scrapea su puerto metrics cada 15 segundos”.

Metricas del Cluster

El stack incluye exporters que recolectan metricas automaticamente:

Node Exporter (metricas de nodos)

node_cpu_seconds_total: uso de CPU por core
node_memory_MemAvailable_bytes: memoria disponible
node_disk_io_time_seconds_total: actividad de disco
node_network_receive_bytes_total: trafico de red

kube-state-metrics (estado de objetos)

kube_pod_status_phase: fase actual de cada pod
kube_deployment_spec_replicas: replicas deseadas
kube_node_status_condition: estado de los nodos

cAdvisor (metricas de contenedores)

container_cpu_usage_seconds_total: CPU por contenedor
container_memory_usage_bytes: memoria por contenedor

Grafana

Acceder al Dashboard

Expone Grafana con port-forward:

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

Accede en http://localhost:3000 con usuario admin y el password configurado.

Dashboards Preconfigurados

El stack incluye dashboards listos para usar:

Kubernetes / Compute Resources / Cluster: vista general de CPU y memoria del cluster
Kubernetes / Compute Resources / Namespace (Pods): recursos por namespace
Kubernetes / Networking / Pod: trafico de red por pod
Node Exporter / Nodes: metricas detalladas de cada nodo

Encuentra estos dashboards en el menu lateral: Dashboards > Browse.

Crear Paneles Personalizados

Para crear un nuevo panel:

Click en + > Dashboard > Add visualization
Selecciona Prometheus como datasource
Escribe una query PromQL, por ejemplo:

# Porcentaje de CPU usado por namespace
sum(rate(container_cpu_usage_seconds_total{namespace!=""}[5m]))
  by (namespace)

Configura el tipo de visualizacion (grafico, gauge, tabla)
Guarda el dashboard

Alertas

Configurar Alertmanager

El chart ya incluye Alertmanager. Configura las notificaciones en los values:

# En monitoring-values.yaml
alertmanager:
  config:
    route:
      receiver: 'slack-notifications'
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 4h
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/TU/WEBHOOK/URL'
            channel: '#alertas-k3s'
            send_resolved: true

Reglas de Alerta

El stack incluye reglas predefinidas. Puedes agregar las tuyas con PrometheusRule:

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: alertas-custom
  namespace: monitoring
  labels:
    release: kube-prometheus
spec:
  groups:
    - name: custom.rules
      rules:
        - alert: PodDown
          expr: kube_pod_status_phase{phase="Failed"} > 0
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "Pod {{ $labels.pod }} en estado Failed"

        - alert: HighCPU
          expr: |
            (1 - avg by(instance)
              (rate(node_cpu_seconds_total{mode="idle"}[5m]))
            ) > 0.85
          for: 10m
          labels:
            severity: critical
          annotations:
            summary: "CPU del nodo {{ $labels.instance }} sobre 85%"

Aplica la regla:

kubectl apply -f alertas-custom.yaml

Consumo de Recursos

El stack de monitoring consume recursos significativos. Estos son valores tipicos en un cluster K3s pequeno:

Componente	CPU Request	Memoria Request
Prometheus	200m	512Mi
Grafana	100m	128Mi
Alertmanager	50m	64Mi
Node Exporter	50m	30Mi
kube-state-metrics	10m	32Mi

Ajustar para Recursos Limitados

Si tu nodo tiene poca RAM, reduce la retencion y los recursos:

prometheus:
  prometheusSpec:
    retention: 3d
    resources:
      limits:
        memory: 512Mi
    storageSpec:
      volumeClaimTemplate:
        spec:
          resources:
            requests:
              storage: 5Gi

En nodos con menos de 4GB de RAM, considera usar soluciones mas ligeras como metrics-server para metricas basicas sin el stack completo.

Resumen

El monitoring es esencial para operar un cluster de forma confiable. Con kube-prometheus-stack obtienes un sistema completo de metricas, visualizacion y alertas con un solo comando de Helm. Ajusta los recursos segun la capacidad de tu cluster.

Siguiente: Capitulo 15: Logs y Debugging —>