Consulta datos del servicio de Prometheus

Después de implementar el servicio administrado de Google Cloud para Prometheus, puedes consultar los datos enviados al servicio administrado y mostrar los resultados en gráficos y paneles.

En este documento, se describen los permisos de métricas, que determinan los datos que puedes consultar, y las siguientes formas de recuperar y usar los datos que recopilaste:

  • Interfaces basadas en Prometheus:

    • Página de Servicio administrado para Prometheus en Google Cloud Console
    • API de HTTP para Prometheus
    • IU de Prometheus
    • Grafana
  • Cloud Monitoring en Google Cloud Console

Antes de comenzar

Si aún no implementaste el servicio administrado, configura la colección administrada o la colección autoimplementada.

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 herramienta de gcloud para hacer referencia al ID del proyecto de Cloud:

      gcloud config set project PROJECT_ID
      
    • Configura la herramienta 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 una cuenta de servicio para Workload Identity

Puedes omitir esta sección si tu clúster de Kubernetes no tiene habilitada Workload Identity.

El servicio administrado para Prometheus captura datos de métricas mediante la API de Cloud Monitoring. Si tu clúster usa Workload Identity, debes otorgar permiso a tu cuenta de servicio de Kubernetes a la API de Monitoring. En esta sección, se describe lo siguiente:

Crea y vincula la cuenta de servicio

Este paso aparece en varios lugares en la documentación del servicio administrado para Prometheus. Si ya realizaste este paso como parte de una tarea anterior, no es necesario que lo repitas. Ve a la sección Autoriza la cuenta de servicio.

Con la siguiente secuencia de comandos, se crea la cuenta de servicio gmp-test-sa y se la vincula a la cuenta de servicio de Kubernetes predeterminada en el espacio de nombres gmp-test:

gcloud iam service-accounts create gmp-test-sa \
&&
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[gmp-test/default]" \
  gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
&&
kubectl annotate serviceaccount \
  --namespace gmp-test \
  default \
  iam.gke.io/gcp-service-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Si usas un espacio de nombres o una cuenta de servicio de GKE diferentes, ajusta los comandos de forma adecuada.

Autoriza la cuenta de servicio

Los grupos de permisos relacionados se recopilan en funciones y se otorgan las funciones a una principal, en este ejemplo, la cuenta de servicio de Google Cloud. Para obtener más información sobre las funciones de Monitoring, consulta Control de acceso.

Con el siguiente comando, se otorga a la cuenta de servicio de Google Cloud, gmp-test-sa, las funciones de la API de Monitoring que necesita para leer datos de métricas.

Si ya otorgaste a la cuenta de servicio de Google Cloud una función específica como parte de la tarea anterior, no necesitas volver a hacerlo.

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

Workload Identity en entornos de producción

En el ejemplo descrito en este documento, se vincula la cuenta de servicio de Google Cloud a la cuenta de servicio de Kubernetes predeterminada y se le otorga a la cuenta de servicio de Google Cloud todos los permisos necesarios para usar la API de Monitoring.

En un entorno de producción, se recomienda usar un enfoque más detallado, con una cuenta de servicio para cada componente, cada una con permisos mínimos. Si deseas obtener más información sobre la configuración de cuentas de servicio para la administración de identidades de cargas de trabajo, consulta Usa Workload Identity.

Permisos de las consultas y las métricas

Los datos que puedes consultar se determinan por el permiso de las métricas de construcción de Cloud Monitoring, independientemente del método que uses para consultar los datos. Por ejemplo, si usas Grafana para consultar el servicio administrado de datos de Prometheus, cada permiso de métrica debe configurarse como una fuente de datos independiente.

Un alcance de métricas de Monitoring es una construcción de solo lectura que te permite supervisar varios proyectos de Google Cloud desde un proyecto de Cloud designado, llamado proyecto de permisos, que aloja un métricas de los permisos.

De forma predeterminada, un proyecto es el proyecto de permisos para su propio permiso de métricas, y el permiso de métricas contiene las métricas y la configuración de ese proyecto. Un proyecto puede tener más de un proyecto en su permiso de métricas, y las métricas y opciones de configuración de todos los proyectos en el permiso de métricas son visibles para el proyecto de permisos. Un proyecto también puede pertenecer a más de un permiso de métricas.

Cuando consultas las métricas de un proyecto y si ese proyecto aloja un permiso de métricas de varios proyectos, puedes recuperar datos de varios proyectos.

Para obtener más información sobre los proyectos de permisos y los permisos de métricas, consulta Permisos de las métricas. Si deseas obtener información para configurar los permisos de las métricas de varios proyectos, consulta Visualiza métricas de varios proyectos.

Página de servicios administrados para Prometheus

La forma más sencilla de verificar que se exportan los datos de Prometheus es usar la página Servicio administrado para Prometheus basado en PromQL en Google Cloud Console.

Para ver esta página, haz lo siguiente:

  1. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:

    Ir a Monitoring

  2. En el panel de navegación de Monitoring, haz clic en Prometheus administrado.

En la página Servicio administrado para Prometheus, puedes usar las consultas de PromQL a fin de recuperar y graficar los datos recopilados con el servicio administrado. En esta página, se pueden consultar solo los datos recopilados por el servicio administrado para Prometheus.

En la siguiente captura de pantalla, se muestra un gráfico que muestra la métrica up:

Servicio administrado para el gráfico de Prometheus de la métrica “up” de Prometheus.

API de HTTP para Prometheus

El servicio administrado para Prometheus admite la API de HTTP para Prometheus ascendente en la URL con el prefijo https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/. Si deseas obtener información sobre los extremos admitidos, consulta Compatibilidad de API.

Cualquier herramienta que pueda interactuar con un servidor estándar de Prometheus puede acceder a esta API. Este es solo un extremo de API, no entrega una IU. Como API de Google Cloud, la API usa la autenticación OAuth2 y, como parte de la API de Cloud Monitoring, el valor de PROJECT_ID es el proyecto de permisos de un permiso de métricas, por lo que puedes recuperar datos desde cualquier proyecto en el permiso de las métricas. Para obtener más información sobre el alcance, consulta Permisos de métricas.

Para usar este extremo, proporciona una expresión PromQL. Por ejemplo, la siguiente consulta instantánea recupera todas las series temporales que tienen el nombre de la métrica up:

curl https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/query \
  -d "query=up" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)"

Si la solicitud se realiza correctamente, la consulta muestra un resultado similar al siguiente, que tiene un formato para facilitar la lectura:

{
  "status":"success",
  "data":{
    "resultType":"vector",
    "result":[{
      "metric": {
        "__name__":"up",
        "cluster":"gmp-test",
        "instance":"prom-example-84c6f547f5-g4ljn:web",
        "job":"prometheus",
        "location":"us-central1-a",
        "project_id":"a-gcp-project"
      },
      "value": [1634873239.971,"1"]
    }]
  }
}

Puedes usar PromQL solo a fin de consultar las métricas que transfiere el servicio administrado para los recopiladores de Prometheus. No puedes consultar las métricas del sistema de Google Cloud mediante PromQL.

IU de Prometheus

Puedes usar la IU de Prometheus para acceder a los datos transferidos y visualizarlos. Esta IU ejecuta consultas de PromQL en todos los datos de tu proyecto de Google Cloud, según lo determina el permiso de las métricas asociado con tu proyecto.

La IU también actúa como un proxy de autenticación para acceder a los datos transferidos. Esta característica se puede usar para herramientas cliente que no son compatibles con OAuth2, incluido Grafana. Si planeas usar Grafana a fin de visualizar datos del Servicio administrado para Prometheus, también debes implementar la IU de Prometheus.

Implementa la IU

Para implementar la IU de Prometheus para el servicio administrado de Prometheus, ejecuta los siguientes comandos:

  1. Implementa el servicio frontend y configúralo para consultar el proyecto de permisos del permiso de métricas que elijas:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.1.1/examples/frontend.yaml |
    sed 's/\$PROJECT_ID/PROJECT_ID/' |
    kubectl apply -n gmp-test -f -
    
  2. Redirecciona los servicios de frontend a tu máquina local. En el siguiente ejemplo, se reenvía el servicio al puerto 9090:

    kubectl -n gmp-test port-forward svc/frontend 9090
    

    Este comando no muestra y, mientras se ejecuta, informa los accesos a la URL.

Si deseas continuar usando una implementación de Grafana instalada por kube-prometheus, implementa la IU de Prometheus en el espacio de nombres monitoring en su lugar.

Puedes acceder a la IU de Prometheus en tu navegador en la URL http://localhost:9090. Si usas Cloud Shell para este paso, puedes obtener acceso mediante el botón Vista previa en la Web.

En la siguiente captura de pantalla, se muestra una tabla en la IU de Prometheus que muestra la métrica up:

Visualiza una métrica en la IU de Prometheus

También puedes configurar la autenticación y autorización adecuadas en el servicio frontend mediante, por ejemplo, Identity-Aware Proxy. Para obtener más información sobre la exposición de servicios, consulta Expón aplicaciones mediante servicios.

Proporciona credenciales de forma explícita

Cuando se ejecuta en GKE, el frontend recupera de forma automática las credenciales 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 son de GKE, las credenciales deben proporcionarse de forma explícita al frontend mediante marcas o la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

  1. Crea una cuenta de servicio:

    gcloud iam service-accounts create gmp-test-sa
    

    En este paso, se crea la cuenta de servicio que puedes haber creado ya en las instrucciones de Workload Identity.

  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.viewer
    

  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-test create secret generic gmp-test-sa \
      --from-file=key.json=gmp-test-sa-key.json
    

  5. Abre el recurso de implementación de frontend para editarlo:

    kubectl -n gmp-test edit deploy frontend
    
  6. Agrega el texto que se muestra en negrita al recurso:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      namespace: gmp-test
      name: frontend
    spec:
      template
        containers:
        - name: frontend
          args:
          - --query.credentials-file=/gmp/key.json
    ...
          volumeMounts:
          - name: gmp-sa
            mountPath: /gmp
            readOnly: true
    ...
        volumes:
        - name: gmp-sa
          secret:
            secretName: gmp-test-sa
    ...
    

  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.

Como alternativa, en lugar de usar las marcas establecidas en este ejemplo, puedes establecer la ruta del archivo de claves mediante la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

Cambia el proyecto consultado

La implementación frontend usa el proyecto de Google Cloud del clúster como el proyecto de permisos. Si este proyecto es el proyecto de permisos de un permiso de métricas de varios proyectos, puede leer métricas de todos los proyectos en el permiso de las métricas.

Para especificar un proyecto diferente mediante la marca --query.project-id.

Por lo general, usas un proyecto dedicado como proyecto de alcance, y este proyecto no es el mismo en el que se ejecuta la implementación de frontend. Para permitir que la implementación lea un proyecto de destino diferente, debes hacer lo siguiente:

  • Indica a la implementación de frontend cuál es el proyecto de destino.
  • Otorga permiso a la cuenta de servicio para leer el proyecto de destino. Si usaste la cuenta de servicio default de Compute Engine, puedes realizar una de las siguientes acciones:

A fin de otorgar los permisos necesarios para acceder a un proyecto de Cloud diferente, haz lo siguiente:

  1. Otorga permiso a la cuenta de servicio para leer el proyecto de destino que deseas consultar:

    gcloud projects add-iam-policy-binding SCOPING_PROJECT_ID \
      --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
      --role=roles/monitoring.viewer
    
  2. Abre la implementación frontend que creaste antes para editarla:

    kubectl -n gmp-test edit deploy frontend
    
  3. Especifica el proyecto de destino con la marca --query.project-id:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      namespace: gmp-test
      name: frontend
    spec:
      template
        containers:
        - name: frontend
          args:
          - --query.project-id=SCOPING_PROJECT_ID
    ...
    

    Guarda el archivo y cierra el editor. Después de aplicar el cambio, los Pods de frontend se reinician y consultan el proyecto de alcance nuevo.

Grafana

Grafana no admite la autenticación OAuth2 para fuentes de datos de Prometheus. Si deseas usar Grafana con un servicio administrado para la fuente de datos de Prometheus, debes usar la IU de Prometheus como un proxy de autenticación.

Si aún no implementaste la IU de Prometheus, impleméntala ahora.

Implementa Grafana

Si ya tienes una implementación de Grafana, puedes acceder a ella de la manera habitual.

Si no tienes una implementación de Grafana en ejecución en tu clúster, puedes crear una implementación de prueba efímera para experimentar.

A fin de crear una implementación efímera de Grafana, aplica el manifiesto grafana.yaml del servicio administrado para Prometheus a tu clúster y redirecciona el servicio grafana a tu máquina local. En el siguiente ejemplo, se reenvía el servicio al puerto 3000.

  1. Aplica el manifiesto grafana.yaml:

    kubectl -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.1.1/examples/grafana.yaml
    
  2. Redirecciona los servicios de frontend a tu máquina local. En este ejemplo, se reenvía el servicio al puerto 9090:

    kubectl -n gmp-test port-forward svc/grafana 3000
    

    Este comando no muestra y, mientras se ejecuta, informa los accesos a la URL.

    Puedes acceder a Grafana en tu navegador en la URL http://localhost:3000 con el nombre de usuario:contraseña admin:admin. Si usas Cloud Shell para este paso, puedes obtener acceso mediante el botón Vista previa en la Web.

Configura una fuente de datos

Para consultar el servicio administrado para Prometheus en Grafana mediante la IU de Prometheus como proxy de autenticación, debes agregar una fuente de datos nueva a Grafana. Si deseas agregar una fuente de datos para el servicio administrado, haz lo siguiente:

  1. Ve a la implementación de Grafana, por ejemplo, si navegas a la URL http://localhost:3000 para llegar a la página de bienvenida de Grafana.

  2. Selecciona Configuración en el menú principal de Grafana y, luego, selecciona Fuentes de datos.

    Agrega una fuente de datos en Grafana.

  3. Selecciona Agregar fuente de datos (Add data source) y selecciona Prometheus como la base de datos de series temporales.

    Agrega una fuente de datos de Prometheus.

  4. En el campo URL del panel HTTP, ingresa la URL del servicio administrado para el servicio frontend de Prometheus. Si configuraste la IU de Prometheus para que se ejecute en el puerto 9090, la URL del servicio de este campo es http://frontend.gmp-test.svc:9090.

    En el campo Método HTTP, selecciona GET.

    Si tienes varias fuentes de datos de Prometheus, puedes asignar un nombre como “Servicio administrado de Prometheus”. Puedes dejar otros campos con sus valores predeterminados.

    Configura un servicio administrado para la fuente de datos de Prometheus.

  5. Haz clic en Probar y guardar (Test and Save) y busca el mensaje “La fuente de datos funciona” (The data source is working).

    Probar el servicio administrado para la fuente de datos de Prometheus

Usa la fuente de datos nueva

Ahora puedes crear paneles de Grafana mediante la fuente de datos nueva. También puedes redireccionar los paneles existentes a la fuente de datos nueva. En la siguiente captura de pantalla, se muestra un gráfico de Grafana que muestra la métrica up:

Gráfico de Grafana para la métrica “up” del servicio administrado para Prometheus.

Servicio administrado para datos de Prometheus en Cloud Monitoring

El servicio administrado para Prometheus comparte el backend de almacenamiento de datos, Monarch, con Cloud Monitoring. Puedes usar todas las herramientas que proporciona Cloud Monitoring con los datos que recopila el servicio administrado para Prometheus. Por ejemplo, puedes usar el Explorador de métricas, como se describe en Cloud Console para Monitoring.

Cuando trabajas con servicios administrados para datos de Prometheus en Monitoring, usa las herramientas de consultas que proporciona Cloud Monitoring:

Cloud Monitoring no es compatible con PromQL, excepto en la página de Servicio administrado para Prometheus.

El recurso prometheus_target

En Cloud Monitoring, los datos de series temporales se escriben en un tipo de recurso supervisado. Para las métricas de Prometheus, el tipo de recurso supervisado es prometheus_target. Las consultas de supervisión para los datos de servicio administrado de Prometheus deben especificar este tipo de recurso.

El recurso prometheus_target tiene las siguientes etiquetas, que puedes usar para filtrar y manipular datos consultados:

  • project_id: El identificador del proyecto de Google Cloud asociado a este recurso.
  • location: La ubicación física (región del proyecto de Cloud) en la que se recopilan y almacenan los datos. Este valor suele ser la región de tu clúster de GKE o instancia de Compute Engine. Si se recopilan datos de una implementación local o de AWS, el valor puede ser la región del proyecto de Cloud más cercana.
  • cluster: el clúster de GKE o el concepto relacionado; podría estar vacío.
  • namespace: El espacio de nombres de GKE o el concepto relacionado podría estar vacío.
  • job: La etiqueta de trabajo del destino de Prometheus, si se conoce; puede estar vacía para los resultados de la evaluación de reglas.
  • instance: La etiqueta de la instancia del destino de Prometheus, si se conoce; puede estar vacía para los resultados de la evaluación de la regla.

Los valores de estas etiquetas se establecen durante la recopilación.

Cloud Console para Monitoring

Para ver el servicio administrado para los datos de Prometheus como series temporales de Cloud Monitoring, puedes usar el Explorador de métricas. Si deseas configurar el Explorador de métricas para mostrar métricas, haz lo siguiente:

  1. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:

    Ir a Monitoring

  2. En el panel de navegación de Monitoring, haz clic en  Explorador de métricas.

  3. Especifica los datos que deben aparecer en el gráfico. Puedes usar la pestaña MQL o la pestaña Configuración.

    • Para usar la pestaña MQL, haz lo siguiente:

      1. Selecciona la pestaña MQL.

      2. Ingrese la siguiente consulta:

        fetch prometheus_target::prometheus.googleapis.com/up/gauge
        
      3. Haga clic en Ejecutar consulta.

    • Para usar la pestaña Configuración, haz lo siguiente:

      1. Selecciona la pestaña Configuración.

      2. En el campo Tipo de recurso, escribe “prometheus” para filtrar la lista y, luego, selecciona Destino de Prometheus.

      3. En el campo Métrica, escribe “up/” para filtrar la lista y selecciona prometheus/up/gauge.

En la siguiente captura de pantalla, se muestra el gráfico del Explorador de métricas de la pestaña MQL que muestra la métrica up:

Gráfico del Explorador de métricas de la métrica de servicio de Prometheus para la métrica “up”.

Compatibilidad de API

Los siguientes extremos de la API de HTTP para Prometheus son compatibles con el servicio administrado para Prometheus con la URL con el prefijo https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/.

  • Los siguientes extremos son totalmente compatibles:

    • /api/v1/query
    • /api/v1/query_range
    • /api/v1/metadata

    Para obtener información sobre la compatibilidad con PromQL, consulta Compatibilidad con PromQL.

  • El extremo /api/v1/$label/values solo admite la etiqueta __name__. Esta limitación hace que las consultas variables de label_values($label) en Grafana fallen. En su lugar, puedes usar label_values($metric, $label). Se recomienda este tipo de consulta, porque evita recuperar valores de etiquetas en métricas que no son relevantes para el panel determinado.

  • El extremo /api/v1/series es compatible con solicitudes GET, pero no con POST. Cuando usas el proxy de frontend, el proxy administra esta restricción por ti. También puedes configurar las fuentes de datos de Prometheus en Grafana para emitir solo solicitudes GET.