Comienza a usar la recopilación administrada

En este documento, se describe cómo configurar el Servicio administrado de Google Cloud para Prometheus con la recopilación administrada. La configuración es un ejemplo mínimo de transferencia de trabajo, mediante una implementación de Prometheus que supervisa una aplicación de ejemplo y almacena métricas recopiladas en Monarch.

Este documento te muestra cómo hacer lo siguiente:

  • Configurar el entorno y las herramientas de línea de comandos.
  • Configurar la recopilación administrada para tu clúster.
  • Configurar un recurso para la recopilación de destino y la transferencia de métricas.
  • Migrar los recursos personalizados de operadores de Prometheus existentes.

Te recomendamos que uses la recopilación administrada. Reduce la complejidad de implementar, escalar, fragmentar, configurar y mantener los colectores. La recopilación administrada es compatible con GKE y cualquier otro entorno de Kubernetes. Para obtener más información sobre la recopilación de datos administrados y autoimplementados, consulta Recopilación de datos con el servicio administrado para Prometheus.

Antes de comenzar

En esta sección, se describe la configuración necesaria para las tareas descritas en este documento.

Configura proyectos y herramientas

Si deseas usar el Servicio administrado de Google Cloud para Prometheus, necesitas los siguientes recursos:

  • Un proyecto de Google Cloud con la API de Cloud Monitoring habilitada

    • Si no tienes un proyecto de Cloud, haz lo siguiente:

      1. En la consola de Cloud, ve a Proyecto nuevo.

        Crear un proyecto nuevo

      2. En el campo Nombre del proyecto, ingresa un nombre para tu proyecto y, luego, haz clic en Crear.

      3. Ve a facturación:

        Ir a Facturación

      4. Selecciona el proyecto que acabas de crear si aún no está seleccionado en la parte superior de la página.

      5. Se te solicitará que elijas un perfil de pagos existente o que crees uno nuevo.

      La API de Monitoring está habilitada de forma predeterminada para proyectos nuevos.

    • Si ya tienes un proyecto de Cloud, asegúrate de que la API de Monitoring esté habilitada:

      1. Ve a API y servicios:

        Ir a API y servicios (APIs & Services)

      2. Selecciona tu proyecto.

      3. Haga clic en Habilitar API y servicios.

      4. Busca “Monitoring”.

      5. En los resultados de la búsqueda, haz clic en "API de Cloud Monitoring".

      6. Si no se muestra "API habilitada", haz clic en el botón Habilitar.

  • Un clúster de Kubernetes. Si no tienes un clúster de Kubernetes, sigue las instrucciones en la Guía de inicio rápido para GKE.

También necesitas las siguientes herramientas de línea de comandos:

  • gcloud
  • kubectl

Las herramientas gcloud y kubectl forman parte de la CLI de Google Cloud. Para obtener información sobre cómo instalarlos, consulta Administra los componentes de la CLI de Google Cloud. Para ver los componentes de la CLI de gcloud que instalaste, ejecuta el siguiente comando:

gcloud components list

Configura tu entorno

Para evitar ingresar repetidamente el ID del proyecto o el nombre del clúster, realiza la siguiente configuración:

  • Configura las herramientas de línea de comandos como se indica a continuación:

    • Configura la CLI de gcloud para hacer referencia al ID del proyecto de Cloud:

      gcloud config set project PROJECT_ID
      
    • Configura la CLI de kubectl para usar tu clúster:

      kubectl config set-cluster CLUSTER_NAME
      

    Para obtener más información sobre estas herramientas, consulta lo siguiente:

Configura un espacio de nombres

Crea el espacio de nombres gmp-test de Kubernetes para los recursos que crees como parte de la aplicación de ejemplo:

kubectl create ns gmp-test

Configura la recopilación administrada

Para descargar e implementar una colección administrada en tu clúster, debes aplicar los manifiestos setup y operator para el servicio administrado. Puedes aplicar los manifiestos de la siguiente manera:

  • La consola de Google Cloud para Google Kubernetes Engine
  • Google Cloud CLI. Para usar la CLI de gcloud, debes ejecutar la versión 1.21.4-gke.300 o posterior de GKE, y debes instalar el componente beta de la CLI de gcloud.
  • La CLI de kubectl para entornos de Kubernetes que no son de GKE.

Cloud Console

Puedes hacer lo siguiente con la consola de Cloud:

  • Aplicar los manifiestos a un clúster de GKE existente.
  • Crear un nuevo clúster de GKE con los manifiestos aplicados.

Para actualizar un clúster existente con los manifiestos, haz lo siguiente:

  1. En la consola de Cloud, selecciona Kubernetes Engine o usa el siguiente botón:

    Ir a Kubernetes Engine

  2. Selecciona Clústeres.

  3. Haz clic en el nombre del clúster.

  4. En la lista Funciones, busca la opción Managed Service para Prometheus. Si aparece como inhabilitado, haz clic en Editar y, luego, selecciona Habilitar Managed Service para Prometheus.

  5. Haz clic en Guardar cambios.

Para crear un clúster con los manifiestos aplicados, haz lo siguiente:

  1. En la consola de Cloud, selecciona Kubernetes Engine o usa el siguiente botón:

    Ir a Kubernetes Engine

  2. Selecciona Clústeres.

  3. Haga clic en Crear.

  4. Haz clic en Configurar en la opción GKE Standard y configura el clúster mediante el panel Conceptos básicos del clúster.

  5. En el panel de navegación, haz clic en Funciones.

  6. En la sección Operaciones, selecciona Habilitar Managed Service para Prometheus.

  7. Haz clic en Guardar.

CLI de gcloud

Puedes hacer lo siguiente con la CLI de gcloud:

  • Aplicar los manifiestos a un clúster de GKE existente.
  • Crear un nuevo clúster de GKE con los manifiestos aplicados.

Estos comandos pueden tardar hasta 5 minutos en completarse.

Para actualizar un clúster existente con los manifiestos, ejecuta uno de los siguientes comandos update en función de si el clúster es zonal o regional:

  • gcloud beta container clusters update CLUSTER_NAME --enable-managed-prometheus --zone ZONE
    
  • gcloud beta container clusters update CLUSTER_NAME --enable-managed-prometheus --region REGION
    

Para crear un clúster con los manifiestos aplicados, ejecuta el siguiente comando:

gcloud beta container clusters create CLUSTER_NAME --zone ZONE --enable-managed-prometheus

kubectl CLI

Para aplicar los manifiestos cuando usas un clúster de Kubernetes que no es de GKE, ejecuta los siguientes comandos:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/manifests/setup.yaml

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/manifests/operator.yaml

Después de aplicar los manifiestos, la recopilación administrada se ejecutará, pero aún no se generarán métricas. Debes implementar un recurso de PodMonitoring que recopile un extremo de métricas válido para ver cualquier dato en la IU de consulta.

Para obtener documentación de referencia sobre el operador de servicio administrado para Prometheus, consulta la página de manifiestos.

Implementa la aplicación de ejemplo

El servicio administrado proporciona un manifiesto para una aplicación de ejemplo que emite métricas de Prometheus en su puerto metrics. La aplicación usa tres réplicas.

Para implementar la aplicación de ejemplo, ejecuta el siguiente comando:

kubectl -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml

Configura un recurso PodMonitoring

Para transferir los datos de métricas que emite la aplicación de ejemplo, usa la recopilación de objetivos. La recopilación de objetivos y la transferencia de métricas se configuran mediante los recursos personalizados de Kubernetes. El servicio administrado usa recursos personalizados (CR) de PodMonitoring.

Un CR de PodMonitoring recopila objetivos solo en el espacio de nombres en el que se implementa el CR. Para recopilar objetivos en varios espacios de nombres, implementa el mismo CR de PodMonitoring en cada espacio de nombres. Para verificar que el recurso PodMonitoring esté instalado en el espacio de nombres deseado, ejecuta kubectl get podmonitoring -A.

A fin de obtener documentación de referencia sobre todos los servicios administrados para las CR de Prometheus, consulta la referencia de prometheus-engine/doc/api.

El siguiente manifiesto define un recurso PodMonitoring, prom-example, en el espacio de nombres gmp-test. El recurso usa un selector de etiquetas de Kubernetes para buscar todos los Pods en el espacio de nombres que tienen la etiqueta app con el valor prom-example. Los Pods coincidentes se copian en un puerto llamado metrics, cada 30 segundos, en la ruta HTTP /metrics.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: prom-example
spec:
  selector:
    matchLabels:
      app: prom-example
  endpoints:
  - port: metrics
    interval: 30s

Para aplicar este recurso, ejecuta el siguiente comando:

kubectl -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

El colector administrado ahora recopila los Pods coincidentes.

Para configurar la recopilación horizontal que se aplica a un rango de pods en todos los espacios de nombres, usa el recurso ClusterPodMonitoring. El recurso ClusterPodMonitoring proporciona la misma interfaz que el recurso de PodMonitoring, pero no limita los pods detectados en un espacio de nombres determinado.

Si ejecutas en GKE, puedes hacer lo siguiente:

Si ejecutas fuera de GKE, debes crear una cuenta de servicio y autorizarla para que escriba tus datos de métricas, como se describe en la siguiente sección.

Proporciona credenciales de forma explícita

Cuando se ejecuta en GKE, el servidor de recopilación de Prometheus recupera credenciales de forma automática del entorno según la cuenta de servicio predeterminada de Compute Engine o la configuración de Workload Identity.

En los clústeres de Kubernetes que no sean de GKE, las credenciales deben proporcionarse de manera explícita a través del recurso OperatorConfig en el espacio de nombres gmp-public.

  1. Crea una cuenta de servicio:

    gcloud iam service-accounts create gmp-test-sa
    

  2. Otorga permisos obligatorios a la cuenta de servicio:

    gcloud projects add-iam-policy-binding PROJECT_ID\
      --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
      --role=roles/monitoring.metricWriter
    

  3. Crea y descarga una clave para la cuenta de servicio:

    gcloud iam service-accounts keys create gmp-test-sa-key.json \
      --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com
    
  4. Agrega el archivo de claves como un secreto a tu clúster que no es de GKE:

    kubectl -n gmp-public create secret generic gmp-test-sa \
      --from-file=key.json=gmp-test-sa-key.json
    

  5. Abre el recurso OperatorConfig para editarlo:

    kubectl -n gmp-public edit operatorconfig config
    

  6. Agrega el texto que se muestra en negrita al recurso:

    apiVersion: monitoring.googleapis.com/v1
    kind: OperatorConfig
    metadata:
      namespace: gmp-public
      name: config
    collection:
      credentials:
        name: gmp-test-sa
        key: key.json
    
    Asegúrate de agregar estas credenciales a la sección rules para que la evaluación de la regla administrada funcione.

  7. Guarda el archivo y cierra el editor. Después de aplicar el cambio, los Pods se vuelven a crear y comienzan a autenticarse en el backend de la métrica con la cuenta de servicio determinada.

Temas adicionales para la recopilación administrada

En esta sección, se describe cómo hacer lo siguiente:

  • Copia las métricas de Kubelet y cAdvisor.
  • Filtra los datos que exportas al servicio administrado.
  • Convierte tus recursos del operador de promesa existentes para usarlos con el servicio administrado.

Recopila métricas de Kubelet y cAdvisor

Kubelet expone las métricas sobre sí mismo y las de cAdvisor sobre contenedores que se ejecutan en su nodo. Pueden transferirse mediante la actualización de OperatorConfig.

  1. Abre el recurso OperatorConfig para editarlo:

    kubectl -n gmp-public edit operatorconfig config
    
  2. Agrega la sección collection, que se muestra en negrita, al recurso:

    apiVersion: monitoring.googleapis.com/v1
    kind: OperatorConfig
    metadata:
      namespace: gmp-public
      name: config
    collection:
      kubeletScraping:
        interval: 15s
    
  3. Guarda el archivo y cierra el editor.

Después de un tiempo breve, los extremos de la métrica de Kubelet se recopilarán y las métricas estarán disponibles para realizar consultas en el servicio administrado de Prometheus.

Filtrar métricas exportadas

Si recopilas muchos datos, es recomendable que evites que algunas series temporales se envíen al servicio administrado para Prometheus a fin de mantener los costos bajos.

Para filtrar las métricas exportadas, puedes configurar un conjunto de selectores de series de PromQL en el recurso OperatorConfig. Se exporta una serie temporal al servicio administrado para Prometheus cuando cumple con al menos uno de los selectores. Es decir, cuando se determina la elegibilidad, las condiciones dentro de un solo selector se usan AND, mientras que las condiciones de selectores diferentes usan OR. De forma predeterminada, no se especifican selectores y se exportan todas las series temporales. En el siguiente ejemplo, se usan dos selectores:

  1. Abre el recurso OperatorConfig para editarlo:

    kubectl -n gmp-public edit operatorconfig config
    
  2. Agrega un filtro collection al recurso, como se muestra en letra negrita a continuación. La sección de configuración filter.matchOneOf tiene la misma semántica que los parámetros match[] para la federación de Prometheus.

    Este filtro de ejemplo solo genera métricas para el trabajo “prometheus” y las métricas producidas que generan las reglas de grabación que se agregan a nivel del trabajo (cuando se siguen las prácticas recomendadas de nombres) que se exportarán. Se filtran las muestras de todas las demás series temporales:

    apiVersion: monitoring.googleapis.com/v1
    kind: OperatorConfig
    metadata:
      namespace: gmp-public
      name: config
    collection:
      filter:
        matchOneOf:
        - '{job="prometheus"}'
        - '{__name__=~"job:.+"}'
    
  3. Guarda el archivo y cierra el editor.

Convierte recursos de operador de Prometheus existentes

Por lo general, puedes convertir los recursos existentes del operador de Prometheus en los servicios administrados de los recursos PodMonitoring y ClusterPodMonitoring de la colección administrada de Prometheus.

Por ejemplo, el recurso ServiceMonitor define la supervisión para un conjunto de servicios. El recurso PodMonitoring entrega un subconjunto de los campos que entrega el recurso ServiceMonitor. Puedes convertir un CR de ServiceMonitor en un CR de PodMonitoring si asignas los campos como se describe en la siguiente tabla:

monitoring.coreos.com/v1
ServiceMonitor
Compatibilidad
 
monitoring.googleapis.com/v1
PodMonitoring
.ServiceMonitorSpec.Selector Idénticos .PodMonitoringSpec.Selector
.ServiceMonitorSpec.Endpoints[] .TargetPort se asigna a .Port
.Path: compatible
.Interval: compatible
.Timeout: compatible
.PodMonitoringSpec.Endpoints[]
.ServiceMonitorSpec.TargetLabels El PodMonitor debe especificar lo siguiente:
.FromPod[].Frometiqueta del pod
.FromPod[].Toetiqueta del objetivo
.PodMonitoringSpec.TargetLabels

El siguiente es un CR de ServiceMonitor de muestra. El contenido en negrita se reemplaza en la conversión y el contenido en cursiva se asigna directamente:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: example-app
spec:
  selector:
    matchLabels:
      app: example-app
  endpoints:
  - targetPort: web
    path: /stats
    interval: 30s
  targetLabels:
  - foo

La siguiente es la CR de PodMonitoring analógica, si tu servicio y sus Pods están etiquetados con app=example-app. Si esta suposición no se aplica, debes usar los selectores de etiquetas del recurso de servicio subyacente.

El contenido en negrita se reemplazó en la conversión:

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: example-app
spec:
  selector:
    matchLabels:
      app: example-app
  endpoints:
  - port: web
    path: /stats
    interval: 30s
  targetLabels:
    fromPod:
    - from: foo # pod label from example-app Service pods.
      to: foo

Siempre puedes seguir usando los recursos existentes del operador de Prometheus y las configuraciones de implementación si usas colectores autoimplementados en lugar de colectores administrados. Puedes consultar las métricas enviadas desde ambos tipos de colectores, por lo que podrías usar colectores autoimplementados para tus implementaciones existentes de Prometheus mientras usas colectores administrados para implementaciones nuevas de Prometheus.

Eliminación

Para inhabilitar la recopilación administrada que se implementó mediante gcloud o la IU de GKE, ejecuta el siguiente comando:

gcloud beta container clusters update CLUSTER_NAME --disable-managed-prometheus

Para inhabilitar la recopilación administrada que se implementó mediante kubectl, ejecuta el siguiente comando:

kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/manifests/operator.yaml

Lecturas adicionales de recursos personalizados de la colección administrada

Para ver la documentación de referencia sobre todos los servicios personalizados de los servicios administrados de Prometheus, consulta la referencia de prometheus-engine/doc/api.

¿Qué sigue?