Cómo monitorear Kubernetes con Prometheus

Introducción

Prometheus es un marco de instrumentación de código abierto. Prometheus puede absorber cantidades masivas de datos cada segundo, lo que lo hace ideal para cargas de trabajo complejas.

Use Prometheus para monitorear sus servidores, máquinas virtuales, bases de datos y aproveche esos datos para analizar el rendimiento de sus aplicaciones e infraestructura.

Este artículo explica cómo configurar la supervisión de Prometheus en un clúster de Kubernetes.

Requisitos previos

• Un clúster de Kubernetes
• Un kubectl completamente configurado interfaz de línea de comandos en su máquina local

Supervisión del clúster de Kubernetes con Prometheus

Prometheus es un sistema basado en extracción. Envía una solicitud HTTP, lo que se conoce como scrape , según la configuración definida en el archivo de implementación . La respuesta a este scrape la solicitud se almacena y analiza en el almacenamiento junto con las métricas para el raspado en sí.

El almacenamiento es una base de datos personalizada en el servidor Prometheus y puede manejar una afluencia masiva de datos. Es posible monitorear miles de máquinas simultáneamente con un solo servidor.

Los datos deben exponerse y formatearse adecuadamente para que Prometheus pueda recopilarlos. Prometheus puede acceder a los datos directamente desde las bibliotecas de clientes de la aplicación o mediante exportadores.

Exportadores se utilizan para datos sobre los que no tiene control total (por ejemplo, métricas del kernel). Un exportador es una pieza de software colocada junto a su aplicación. Su propósito es aceptar solicitudes HTTP de Prometheus, asegurarse de que los datos estén en un formato compatible y luego proporcionar los datos solicitados al servidor de Prometheus.

Todas sus aplicaciones ahora están equipadas para proporcionar datos a Prometheus. Todavía tenemos que informar a Prometheus dónde buscar esos datos. Prometheus descubre objetivos de los que raspar utilizando Detección de servicios .

Su clúster de Kubernetes ya tiene etiquetas y anotaciones y un excelente mecanismo para realizar un seguimiento de los cambios y el estado de sus elementos. Por lo tanto, Prometheus usa la API de Kubernetes para descubrir objetivos.

Los descubrimientos del servicio de Kubernetes que puede exponer a Prometheus son:

• nodo
• punto final
• servicio
• vaina
• ingreso

Prometheus recupera las métricas a nivel de máquina por separado de la información de la aplicación. La única forma de exponer las métricas de memoria, espacio en disco, uso de CPU y ancho de banda es usar un exportador de nodos . Además, las métricas sobre cgroups también deben estar expuestas.

Afortunadamente, el exportador de cAdvisor ya está integrado en el nivel de nodo de Kubernetes y puede exponerse fácilmente.

Una vez que el sistema recopila los datos, puede acceder a ellos utilizando el lenguaje de consulta PromQL , exportarlos a interfaces gráficas como Grafana o usarlos para enviar alertas con Alertmanager.

Instalar supervisión de Prometheus en Kubernetes

El monitoreo de Prometheus se puede instalar en un clúster de Kubernetes mediante el uso de un conjunto de archivos YAML (Yet Another Markup Language). Estos archivos contienen configuraciones, permisos y servicios que permiten a Prometheus acceder a los recursos y obtener información extrayendo los elementos de su clúster.

Los archivos YAML se rastrean y editan fácilmente y se pueden reutilizar indefinidamente. Los archivos presentados en este tutorial están disponibles de forma fácil y gratuita en repositorios en línea como GitHub.

Crear espacio de nombres de supervisión

Todos los recursos de Kubernetes se inician en un espacio de nombres. A menos que se especifique uno, el sistema utiliza el espacio de nombres predeterminado. Para tener un mejor control sobre el proceso de monitoreo del clúster, vamos a especificar un espacio de nombres de monitoreo.

El nombre del espacio de nombres debe ser una etiqueta compatible con DNS. Para facilitar la referencia, vamos a nombrar el espacio de nombres:supervisión .

Hay dos formas de crear un espacio de nombres de supervisión para recuperar métricas de la API de Kubernetes.

Opción 1:

Ingrese este comando simple en su interfaz de línea de comandos y cree la supervisión espacio de nombres en su host:

kubectl create namespace monitoring

Opción 2:

Cree y aplique un archivo .yml:

apiVersion: v1
kind: Namespace
metadata:
  name: monitoring

Este método es conveniente ya que puede implementar el mismo archivo en instancias futuras. Aplique el archivo a su clúster ingresando el siguiente comando en su terminal de comando:

kubectl -f apply namespace monitoring.yml

Independientemente del método utilizado, enumere los espacios de nombres existentes mediante este comando:

kubectl get namespaces

Configurar archivo de implementación de Prometheus

La siguiente sección contiene los elementos necesarios para configurar con éxito el raspado de Prometheus en su clúster de Kubernetes y sus elementos.

Las secciones se pueden implementar como .yml individuales archivos ejecutados en secuencia. Después de crear cada archivo, se puede aplicar ingresando el siguiente comando:

kubectl -f apply [name_of_file].yml

En este ejemplo, todos los elementos se colocan en un solo .yml archivo y aplicado simultáneamente.

El prometeo.yml archivo en nuestro ejemplo instruye al kubectl para enviar una solicitud al servidor API de Kubernetes. El archivo contiene:

1. Permisos que permiten a Prometheus acceder a todos los pods y nodos.
2. El mapa de configuración de Prometheus que define qué elementos deben desecharse.
3. Instrucciones de implementación de Prometheus.
4. Un servicio que le da acceso a la interfaz de usuario de Prometheus.

Rol de clúster, cuenta de servicio y enlace de rol de clúster

Los espacios de nombres están diseñados para limitar los permisos de los roles predeterminados si queremos recuperar datos de todo el clúster, debemos otorgar acceso a Prometheus a todos los recursos de ese clúster. Un archivo .yml básico de Prometheus que proporciona acceso a todo el clúster tiene los siguientes elementos:

1. Definir el rol del clúster

Los verbos de cada regla definen las acciones que el rol puede realizar en los apiGroups.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups:
  - extensions
  resources:
  - ingresses
  verbs: ["get", "list", "watch"]

2. Crear cuenta de servicio

Además, necesitamos crear una cuenta de servicio para aplicar este rol a:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
  namespace: monitoring

3. Aplicar ClusterRoleBinding

Finalmente, necesitamos aplicar un ClusterRoleBinding . Esta acción vinculará la cuenta de servicio al rol de clúster creado anteriormente.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: monitoring

Al agregar estos recursos a nuestro archivo, le otorgamos a Prometheus acceso a todo el clúster desde la supervisión espacio de nombres.

Mapa de configuración de Prometheus

Esta sección del archivo proporciona instrucciones para el proceso de raspado. Las instrucciones específicas para cada elemento del clúster de Kubernetes deben personalizarse para que coincidan con sus requisitos de monitoreo y la configuración del clúster.

1. Reglas globales de eliminación

apiVersion: v1
data:
  prometheus.yml: |
    global:
      scrape_interval: 10s

2. Raspar nodo

Este descubrimiento de servicios expone los nodos que componen su clúster de Kubernetes. El kubelet se ejecuta en todos los nodos y es una fuente de información valiosa.

2.1 Raspar kubelet

    scrape_configs:
    - job_name: 'kubelet'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.

2.2 Scrape cAdvisor (información a nivel de contenedor)

El kubelet solo proporciona información sobre sí mismo y no sobre los contenedores. Para recibir información desde el nivel del contenedor, necesitamos usar un exportador. El cAdvisor ya está incrustado y solo necesita una metrics_path : /métricas/cadvisor para que Prometheus recopile datos de contenedores:

    - job_name: 'cadvisor'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.
      metrics_path: /metrics/cadvisor

3. Raspe APIServer

Utilice el rol de puntos finales para apuntar a cada instancia de la aplicación. Esta sección del archivo le permite extraer servidores API en su clúster de Kubernetes.

    - job_name: 'k8apiserver'
      kubernetes_sd_configs:
      - role: endpoints
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required if using Minikube.
      bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
      relabel_configs:
   - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: default;kubernetes;https

4. Scrape Pods para servicios de Kubernetes (excepto servidores API)

Elimine los pods que respaldan todos los servicios de Kubernetes e ignore las métricas del servidor API.

- job_name: 'k8services'
      kubernetes_sd_configs:
      - role: endpoints
      relabel_configs:
      - source_labels:
          - __meta_kubernetes_namespace
          - __meta_kubernetes_service_name
        action: drop
        regex: default;kubernetes
      - source_labels:
          - __meta_kubernetes_namespace
        regex: default
        action: keep
      - source_labels: [__meta_kubernetes_service_name]
        target_label: job

5. Rol de grupo

Descubra todos los puertos de pod con las métricas de nombre utilizando el nombre del contenedor como etiqueta de trabajo.

- job_name: 'k8pods'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_container_port_name]
        regex: metrics
        action: keep
      - source_labels: [__meta_kubernetes_pod_container_name]
        target_label: job
kind: ConfigMap
metadata:
  name: prometheus-config

6. Configurar conjunto de réplicas

Defina la cantidad de réplicas que necesita y una plantilla que se aplicará al conjunto definido de pods.

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: prometheus
spec:
  selector:
    matchLabels:
      app: prometheus
  replicas: 1
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      serviceAccountName: prometheus
      containers:
      - name: prometheus
        image: prom/prometheus:v2.1.0
        ports:
        - containerPort: 9090
          name: default
        volumeMounts:
        - name: config-volume
          mountPath: /etc/prometheus
      volumes:
      - name: config-volume
        configMap:
         name: prometheus-config

7. Definir puerto de nodo

Prometheus se está ejecutando actualmente en el clúster. Agregar la siguiente sección a nuestro prometheus.yml El archivo nos dará acceso a los datos que Prometheus ha recopilado.

kind: Service
apiVersion: v1
metadata:
  name: prometheus
spec:
  selector:
    app: prometheus
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 9090
    targetPort: 9090
    nodePort: 30909

Aplicar archivo prometheus.yml

El mapa de configuración definido en el archivo brinda datos de configuración a cada pod en la implementación:

kubectl apply -f prometheus.yml

Use la URL del nodo individual y el nodePort definido en el prometheus.yml para acceder a Prometheus desde su navegador. Por ejemplo:

http://192.153.99.106:30909

Al ingresar la URL o la IP de su nodo y al especificar el puerto desde el archivo yml, obtuvo acceso con éxito a Prometheus Monitoring.

¿Cómo monitorear kube-state-metrics? (Opcional)

Ahora puede monitorear completamente su infraestructura de Kubernetes, así como también las instancias de su aplicación. Sin embargo, esto no incluye métricas sobre la información que Kubernetes tiene sobre los recursos de su clúster.

Kube-state-metrics es un exportador que permite a Prometheus extraer esa información también. Cree un archivo YAML para el exportador kube-state-metrics:

---
apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: kube-state-metrics
spec:
  selector:
    matchLabels:
      app: kube-state-metrics
  replicas: 1
  template:
    metadata:
      labels:
        app: kube-state-metrics
    spec:
      serviceAccountName: prometheus
      containers:
      - name: kube-state-metrics
        image: quay.io/coreos/kube-state-metrics:v1.2.0
        ports:
        - containerPort: 8080
          name: monitoring
---
kind: Service
apiVersion: v1
metadata:
  name: kube-state-metrics
spec:
  selector:
    app: kube-state-metrics
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

Aplique el archivo ingresando el siguiente comando:

kubectl apply -f kube-state-metrics.yml

Una vez que aplique el archivo, acceda a Prometheus ingresando la IP/URL del nodo y el puerto del nodo definido como se definió anteriormente.