Recoger métricas de Prometheus

En este documento se describe la configuración y el uso de un receptor de métricas del agente de operaciones que puedes usar para recoger métricas de Prometheus en Compute Engine. En este documento también se describe un ejemplo que puedes usar para probar el receptor.

Los usuarios de Google Kubernetes Engine pueden recoger métricas de Prometheus mediante Google Cloud Managed Service para Prometheus. El receptor de Prometheus del agente de operaciones ofrece a los usuarios de Compute Engine la misma función.

Puedes usar todas las herramientas que ofrece Cloud Monitoring, incluido PromQL, para ver y analizar los datos recogidos por el receptor de Prometheus. Por ejemplo, puedes usar Explorador de métricas, como se describe en la consolaGoogle Cloud de monitorización, para consultar tus datos. También puedes crear paneles de control y políticas de alertas de Cloud Monitoring para monitorizar tus métricas de Prometheus. Te recomendamos que uses PromQL como lenguaje de consulta para tus métricas de Prometheus.

También puedes ver tus métricas de Prometheus en interfaces externas a Cloud Monitoring, como la interfaz de usuario de Prometheus y Grafana.

Elegir el receptor adecuado

Antes de decidirte por el receptor de Prometheus, determina si ya hay una integración del agente de Ops para la aplicación que estás usando. Para obtener información sobre las integraciones con el Agente de operaciones, consulta Monitorizar aplicaciones de terceros. Si ya hay una integración, te recomendamos que la uses. Para obtener más información, consulta Elegir una integración ya creada.

Te recomendamos que uses el receptor Prometheus del agente de Ops cuando se cumplan las siguientes condiciones:

• Tienes experiencia con Prometheus, te basas en el estándar de Prometheus y sabes cómo pueden afectar a tus costes factores como el intervalo de raspado y la cardinalidad. Para obtener más información, consulta Elegir el receptor de Prometheus.

• El software que estás monitorizando no forma parte del conjunto de integraciones del Agente de operaciones.

Integraciones actuales

El agente de operaciones proporciona integraciones para varias aplicaciones de terceros. Estas integraciones te ofrecen lo siguiente:

• Un conjunto de workload.googleapis.com métricas seleccionadas para la aplicación
• Un panel de control para visualizar las métricas.

Las métricas ingeridas mediante una integración ya disponible están sujetas a precios basados en bytes para las métricas recogidas por agentes. Para obtener información sobre estos precios, consulta Métricas cobradas por bytes ingeridos. El número y los tipos de métricas se conocen de antemano, por lo que puede usar esa información para estimar los costes.

Por ejemplo, si utiliza la integración del servidor web Apache (httpd), el agente de Ops recoge cinco métricas escalares. Cada punto de datos cuenta como 8 bytes. Si mantienes la frecuencia de muestreo predeterminada del agente de operaciones, que es de 60 segundos,el número de bytes ingeridos al día será 57.600 multiplicado por el número de hosts:

• 8 (bytes) * 1440 (minutos al día) * 5 (métricas) * n (hosts).
• 57.600 * n (hosts)

Para obtener más información sobre cómo estimar los costes, consulta los ejemplos de precios basados en bytes ingeridos.

El receptor de Prometheus

Cuando usas el agente de operaciones para recoger métricas de Prometheus, se aplican las siguientes condiciones:

• El número y la cardinalidad de las métricas emitidas por tu aplicación están bajo tu control. No hay un conjunto de métricas seleccionadas. La cantidad de datos que ingieres se determina en función de la configuración de tu aplicación Prometheus y del receptor de Prometheus del agente de operaciones.

• Las métricas se ingieren en Cloud Monitoring como métricas prometheus.googleapis.com. Estas métricas se clasifican como un tipo de métricas "personalizadas" cuando se ingieren en Cloud Monitoring y están sujetas a las cuotas y límites de las métricas personalizadas.

• Debes diseñar y crear los paneles de Cloud Monitoring que necesites en función del conjunto de métricas que estés ingiriendo y de las necesidades de tu empresa. Para obtener información sobre cómo crear paneles de control, consulta Paneles de control y gráficos.

• El precio de la ingestión de métricas se basa en el número de métricas cobradas por muestras ingeridas. Para estimar los costes al usar el receptor de Prometheus, debe determinar el número de muestras que es probable que recoja durante un ciclo de facturación. La estimación se basa en los siguientes factores:

  • Número de métricas escalares; cada valor es una muestra.
  • Número de métricas de distribución. Cada histograma cuenta como (2 + número de segmentos del histograma) muestras.
  • Frecuencia de muestreo de cada métrica
  • Número de hosts de los que se toman muestras de las métricas.

  Para obtener más información sobre cómo se cuentan las muestras y se estiman los costes, consulta los ejemplos de precios basados en muestras ingeridas.

Requisitos previos

Para recoger métricas de Prometheus mediante el receptor de Prometheus, debes instalar la versión 2.25.0 o una posterior del agente de operaciones.

El receptor del agente de operaciones requiere un endpoint que emita métricas de Prometheus. Por lo tanto, tu aplicación debe proporcionar directamente un endpoint de este tipo o usar una biblioteca o un exportador de Prometheus para exponer un endpoint. Muchas bibliotecas y frameworks de lenguajes, como Spring y DropWizard, o aplicaciones como StatsD, DogStatsD y Graphite, que emiten métricas que no son de Prometheus, pueden usar bibliotecas de cliente o exportadores de Prometheus para emitir métricas de estilo Prometheus. Por ejemplo, para emitir métricas de Prometheus, haz lo siguiente:

• Los usuarios de Spring pueden usar la biblioteca Spring Metrics.
• Los usuarios de StatsD pueden usar el paquete statsd_exporter.
• Los usuarios de Graphite pueden usar el paquete graphite_exporter.

Cuando una aplicación emite métricas de Prometheus, ya sea directamente o mediante una biblioteca o un exportador, un receptor de Prometheus configurado en el agente de operaciones puede recogerlas.

Configurar el agente de operaciones

El modelo de configuración del agente de operaciones suele implicar la definición de lo siguiente:

• Receptores, que determinan qué métricas se recogen.
• Procesadores: describen cómo puede modificar las métricas el agente de operaciones.
• Pipelines, que vinculan receptores y procesadores en un servicio.

La configuración para ingerir métricas de Prometheus es ligeramente diferente: no hay procesadores implicados.

Configuración de métricas de Prometheus

La configuración del agente de operaciones para ingerir métricas de Prometheus difiere de la configuración habitual de la siguiente manera:

• No creas un procesador del agente de operaciones para las métricas de Prometheus. El receptor de Prometheus admite casi todas las opciones de configuración especificadas por la scrape_configespecificación de Prometheus, incluidas las opciones de cambio de etiqueta.

  En lugar de usar un procesador del agente de operaciones, el procesamiento de métricas se realiza mediante las secciones relabel_configs y metric_relabel_configs de la configuración de extracción, tal como se especifica en el receptor de Prometheus. Para obtener más información, consulta Reetiquetado: modificar los datos que se están recogiendo.

• Solo defines la canalización de Prometheus en términos del receptor de Prometheus. No especifica ningún procesador. Tampoco puedes usar ningún receptor que no sea de Prometheus en la canalización de métricas de Prometheus.

La mayor parte de la configuración del receptor es la especificación de las opciones de scrape_config. Para abreviar, a continuación se muestra la estructura de una configuración del agente de operaciones que usa un receptor de Prometheus. Especifica los valores de RECEIVER_ID y PIPELINE_ID.

metrics:
  receivers:
    RECEIVER_ID:
      type: prometheus
      config:
        scrape_configs:
          [... omitted for brevity ...]

  service:
    pipelines:
      PIPELINE_ID:
        receivers: [RECEIVER_ID]

En la siguiente sección se describe el receptor de Prometheus con más detalle. Para ver un ejemplo funcional de un receptor y una canalización, consulta Añadir el receptor y la canalización del agente de Ops.

El receptor de Prometheus

Para especificar un receptor de métricas de Prometheus, crea un receptor de métricas de tipo prometheus y especifica un conjunto de opciones de scrape_config. El receptor admite todas las opciones de Prometheus scrape_config, excepto las siguientes:

• Las secciones de detección de servicios, *_sd_config.
• El ajuste honor_labels.

Por lo tanto, puedes copiar las configuraciones de raspado que ya tengas y usarlas en el agente de operaciones con pocas modificaciones o sin hacer ninguna.

La estructura completa del receptor de Prometheus se muestra a continuación:

metrics:
  receivers:
    prom_application:
      type: prometheus
      config:
        scrape_configs:
          - job_name: 'STRING' # must be unique across all Prometheus receivers
              scrape_interval: # duration, like 10m or 15s
              scrape_timeout:  # duration, like 10m or 15s
              metrics_path: # resource path for metrics, default = /metrics
              honor_timestamps: # boolean, default = false
              scheme: # http or https, default = http
              params:
                - STRING: STRING
              basic_auth:
                username: STRING
                password: SECRET
                password_file: STRING
              authorization:
                type: STRING # default = Bearer
                credentials: SECRET
                credentials_file: FILENAME

              oauth2: OAUTH2 # See Prometheus oauth2
              follow_redirects: # boolean, default = true
              enable_http2: # boolean, default = true
              tls_config: TLS_CONFIG # See Prometheus tls_config
              proxy_url: STRING

              static_configs:
                STATIC_CONFIG # See Prometheus static_config
              relabel_configs:
                RELABEL_CONFIG # See Prometheus relabel_config
              metric_relabel_configs:
                METRIC_RELABEL_CONFIGS # See Prometheus metric_relabel_configs

Para ver ejemplos de configuraciones de cambio de nombre, consulta Configuración adicional de receptores.

Ejemplo: Configurar el agente de operaciones para Prometheus

En esta sección se muestra un ejemplo de cómo configurar el agente de operaciones para recoger métricas de Prometheus de una aplicación. En este ejemplo se usa el exportador JSON proporcionado por la comunidad de Prometheus (json_exporter), que expone métricas de Prometheus en el puerto 7979.

Para configurar el ejemplo, necesitas los siguientes recursos, que puede que tengas que instalar:

• git
• curl
• make
• python3
• Lenguaje Go, versión 1.19 o posterior

Crear o configurar una aplicación

Para obtener y ejecutar JSON Exporter, sigue este procedimiento:

1. Clona el repositorio json_exporter y consulta el exportador ejecutando los siguientes comandos:

   git clone https://github.com/prometheus-community/json_exporter.git
   
   cd json_exporter
   
   git checkout v0.5.0
   

2. Compila el exportador ejecutando el siguiente comando:

   make build
   

3. Inicia el servidor HTTP de Python ejecutando el siguiente comando:

   python3 -m http.server 8000 &
   

4. Inicia JSON Exporter ejecutando el siguiente comando:

   ./json_exporter --config.file examples/config.yml &
   

5. Consulta el exportador de JSON para verificar que se está ejecutando y exponiendo métricas en el puerto 7979:

   curl "http://localhost:7979/probe?module=default&target=http://localhost:8000/examples/data.json"
   

   Si la consulta se ha realizado correctamente, verá un resultado similar al siguiente:

   # HELP example_global_value Example of a top-level global value scrape in the json
   # TYPE example_global_value untyped
   example_global_value{environment="beta",location="planet-mars"} 1234
   # HELP example_value_active Example of sub-level value scrapes from a json
   # TYPE example_value_active untyped
   example_value_active{environment="beta",id="id-A"} 1
   example_value_active{environment="beta",id="id-C"} 1
   # HELP example_value_boolean Example of sub-level value scrapes from a json
   # TYPE example_value_boolean untyped
   example_value_boolean{environment="beta",id="id-A"} 1
   example_value_boolean{environment="beta",id="id-C"} 0
   # HELP example_value_count Example of sub-level value scrapes from a json
   # TYPE example_value_count untyped
   example_value_count{environment="beta",id="id-A"} 1
   example_value_count{environment="beta",id="id-C"} 3
   

   En este resultado, las cadenas como example_value_active son los nombres de las métricas, con etiquetas y valores entre llaves. El valor de datos sigue al conjunto de etiquetas.

Añadir el receptor y la canalización del agente de operaciones

Para configurar el agente de operaciones de forma que ingiera métricas de la aplicación JSON Exporter, debes modificar la configuración del agente para añadir un receptor y una canalización de Prometheus. En el ejemplo de JSON Exporter, sigue estos pasos:

1. Edita el archivo de configuración del agente de operaciones, /etc/google-cloud-ops-agent/config.yaml, y añade las siguientes entradas de receptor y de canalización de Prometheus:

   metrics:
     receivers:
       prometheus:
           type: prometheus
           config:
             scrape_configs:
               - job_name: 'json_exporter'
                 scrape_interval: 10s
                 metrics_path: /probe
                 params:
                   module: [default]
                   target: [http://localhost:8000/examples/data.json]
                 static_configs:
                   - targets: ['localhost:7979']
     service:
       pipelines:
         prometheus_pipeline:
           receivers:
             - prometheus
    

   Si ya tienes otras entradas de configuración en este archivo, añade el receptor y la canalización de Prometheus a las entradas metrics y service. Para obtener más información, consulta Configuraciones de métricas.

   Para ver ejemplos de configuraciones de cambio de nombre en el receptor, consulta Configuración adicional del receptor.

Reiniciar el agente de operaciones

Para aplicar los cambios de configuración, debes reiniciar el agente de Ops.

Métricas de Prometheus en Cloud Monitoring

Puedes usar las herramientas que proporciona Cloud Monitoring con los datos recogidos por el receptor de Prometheus. Por ejemplo, puede representar datos en gráficos con el Explorador de métricas, tal como se describe en la consola deGoogle Cloud Monitoring. En las siguientes secciones se describen las herramientas de consulta disponibles en Cloud Monitoring con el explorador de métricas:

• PromQL
• Filtros de monitorización

Puedes crear paneles de control y políticas de alertas de Cloud Monitoring para tus métricas. Para obtener información sobre los paneles de control y los tipos de gráficos que puedes usar, consulta Paneles de control y gráficos. Para obtener información sobre las políticas de alertas, consulta el artículo Usar políticas de alertas.

También puede ver sus métricas en otras interfaces, como la interfaz de usuario de Prometheus y Grafana. Para obtener información sobre cómo configurar estas interfaces, consulta las siguientes secciones de la documentación de Google Cloud Managed Service para Prometheus:

• Interfaz de Prometheus
• Grafana

Usar PromQL

PromQL es el lenguaje de consulta recomendado para las métricas ingeridas mediante el receptor de Prometheus.

La forma más sencilla de verificar que se están ingiriendo tus datos de Prometheus es usar la página Explorador de métricas de Cloud Monitoring en la Google Cloud consola:

1. En la Google Cloud consola, ve a la página leaderboard Explorador de métricas:

   Ve al explorador de métricas.

   Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuya sección sea Monitorización.

2. En la barra de herramientas del panel de creación de consultas, selecciona el botón cuyo nombre sea code MQL o code PromQL.

3. Verifica que PromQL esté seleccionado en el interruptor Idioma. El interruptor de idioma se encuentra en la misma barra de herramientas que te permite dar formato a tu consulta.

4. Introduce la siguiente consulta en el editor y, a continuación, haz clic en Ejecutar consulta:

   up
   

Si se están ingiriendo datos, verá un gráfico como el siguiente:

Si estás ejecutando el ejemplo de exportador JSON, también puedes hacer consultas como las siguientes:

• Consulta todos los datos de una métrica exportada específica por su nombre. Por ejemplo:

  example_value_count
  

  A continuación, se muestra un gráfico de example_value_count, que incluye etiquetas definidas por la aplicación JSON Exporter y etiquetas añadidas por el agente de operaciones:

  

• Consultar datos de una métrica exportada que se originó en un espacio de nombres específico. El valor de la etiqueta namespace es el ID de la instancia de Compute Engine, un número largo como 5671897148133813325, asignado a la VM. Una consulta tiene el siguiente aspecto:

  example_value_count{namespace="INSTANCE_ID"}
  

• Consulta datos que coincidan con una expresión regular específica. El exportador JSON emite métricas con una etiqueta id que tiene valores como id-A, id-B y id-C. Para filtrar las métricas que tengan una etiqueta id que coincida con este patrón, usa la siguiente consulta:

  example_value_count{id=~"id.*"}
  

Para obtener más información sobre cómo usar PromQL en el explorador de métricas y en los gráficos de Cloud Monitoring, consulta el artículo PromQL en Cloud Monitoring.

Ver el uso de las métricas y los diagnósticos en Cloud Monitoring

La página Gestión de métricas de Cloud Monitoring proporciona información que puede ayudarte a controlar el importe que gastas en métricas facturables sin que esto afecte a la observabilidad. En la página Gestión de métricas se muestra la siguiente información:

• Volúmenes de ingesta para la facturación basada en bytes y en muestras, en todos los dominios de métricas y para métricas concretas.
• Datos sobre las etiquetas y la cardinalidad de las métricas.
• Número de lecturas de cada métrica.
• Uso de métricas en políticas de alertas y paneles de control personalizados.
• Tasa de errores de escritura de métricas.

También puede usar la página Gestión de métricas para excluir las métricas que no necesite y, de esta forma, no incurrir en los costes de ingesta.

Para ver la página Gestión de métricas, haz lo siguiente:

1. En la Google Cloud consola, ve a la página query_stats Gestión de métricas:

   Ve a Gestión de métricas.

   Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuya sección sea Monitorización.

2. En la barra de herramientas, selecciona el periodo que quieras. De forma predeterminada, la página Gestión de métricas muestra información sobre las métricas recogidas en el día anterior.

Para obtener más información sobre la página Gestión de métricas, consulta el artículo Ver y gestionar el uso de métricas.

Reetiquetado: modificar los datos que se extraen

Puedes usar el cambio de etiquetas para modificar el conjunto de etiquetas del objetivo de raspado o sus métricas antes de que se raspe el objetivo. Si tienes varios pasos en una configuración de cambio de etiqueta, se aplican en el orden en el que aparecen en el archivo de configuración.

Ops Agent crea un conjunto de metaetiquetas (etiquetas con el prefijo __meta_). Estas etiquetas de metadatos registran información sobre la instancia de Compute Engine en la que se ejecuta el Agente de operaciones. Las etiquetas que tienen el prefijo __, incluidas las metaetiquetas, solo están disponibles durante el proceso de reetiquetado. Puedes usar el cambio de nombre para registrar los valores de estas etiquetas en etiquetas que se hayan recogido.

El cambio de nombre de las métricas se aplica a las muestras. Es el último paso antes de la ingestión. Puedes usar el cambio de etiquetas de métricas para eliminar las series temporales que no necesites ingerir. Al eliminar estas series temporales, se reduce el número de muestras ingeridas, lo que puede reducir los costes.

Para obtener más información sobre el cambio de etiquetas, consulta la documentación de Prometheus sobre relabel_config y metric_relabel_configs.

Etiquetas de metadatos de Compute Engine disponibles durante el cambio de etiquetas

Cuando el agente de operaciones extrae métricas, incluye un conjunto de metaelementos cuyas valores se basan en la configuración de la VM de Compute Engine en la que se ejecuta el agente. Puedes usar estas etiquetas y la sección relabel_configs del receptor de Prometheus para añadir metadatos adicionales a tus métricas sobre la máquina virtual desde la que se han ingerido. Para ver un ejemplo, consulta Configuración adicional del receptor.

Puede usar las siguientes etiquetas meta en los elementos de destino de la sección relabel_configs:

• __meta_gce_instance_id: ID numérico de la instancia de Compute Engine (local)
• __meta_gce_instance_name: el nombre de la instancia de Compute Engine (local). El Agente de operaciones coloca automáticamente este valor en la etiqueta instance_name mutable de tus métricas.
• __meta_gce_machine_type: URL completa o parcial del tipo de máquina de la instancia. El agente de operaciones coloca automáticamente este valor en la etiqueta mutable machine_type de tus métricas.
• __meta_gce_metadata_NAME: cada elemento de metadatos de la instancia
• __meta_gce_network: la URL de red de la instancia.
• __meta_gce_private_ip: la dirección IP privada de la instancia
• __meta_gce_interface_ipv4_NAME: dirección IPv4 de cada interfaz con nombre
• __meta_gce_project: el Google Cloud proyecto en el que se ejecuta la instancia (local)
• __meta_gce_public_ip: la dirección IP pública de la instancia, si está presente
• __meta_gce_tags: lista de etiquetas de instancia separadas por comas
• __meta_gce_zone: la URL de la zona de Compute Engine en la que se ejecuta la instancia

Los valores de estas etiquetas se definen cuando se inicia el agente de Ops. Si modificas los valores, tendrás que reiniciar el agente de Ops para que se actualicen.

Configuración adicional del receptor

En esta sección se proporcionan ejemplos que usan las secciones relabel_configs y metric_relabel_configs del receptor de Prometheus para modificar el número y la estructura de las métricas ingeridas. Esta sección también incluye una versión modificada del receptor del ejemplo de exportador JSON que usa las opciones de reetiquetado.

relabel_configs:
  - source_labels: [__meta_gce_zone]
    regex: '(.+)'
    replacement: '${1}'
    target_label: zone

metric_relabel_configs:
  - source_labels: [ __name__ ]
    regex: 'METRIC_NAME_REGEX_1'
    action: drop
  - source_labels: [ __name__ ]
    regex: 'METRIC_NAME_REGEX_2'
    action: drop

metric_relabel_configs:
  - source_labels: [ __address__ ]
    action: replace
    replacement: 'STATIC_VALUE_1'
    target_label: staticLabel1
  - source_labels: [ __address__ ]
    action: replace
    replacement: 'STATIC_VALUE_2'
    target_label: staticLabel2

La siguiente versión del receptor de Prometheus para el ejemplo de JSON Exporter usa estos patrones de configuración para hacer lo siguiente:

• Define la etiqueta zone a partir del valor de la etiqueta __meta_gce_zone meta proporcionada por el Agente de operaciones.
• Elimina la métrica example_global_value del exportador.
• Añade la etiqueta staticLabel con el valor "A static value" a todas las métricas ingeridas.

metrics:
  receivers:
    prometheus:
        type: prometheus
        config:
          scrape_configs:
            - job_name: 'json_exporter'
              scrape_interval: 10s
              metrics_path: /probe
              params:
                module: [default]
                target: [http://localhost:8000/examples/data.json]
              static_configs:
                - targets: ['localhost:7979']
              relabel_configs:
                - source_labels: [__meta_gce_zone]
                  regex: '(.+)'
                  replacement: '${1}'
                  target_label: zone
              metric_relabel_configs:
                - source_labels: [ __name__ ]
                  regex: 'example_global_value'
                  action: drop
                - source_labels: [ __address__ ]
                  action: replace
                  replacement: 'A static value'
                  target_label: staticLabel