Después de implementar Google Cloud Managed Service 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 basadas en Prometheus para recuperar y usar los datos que recopilaste:
- La API de HTTP para Prometheus
- La IU de Prometheus
Todas las interfaces de consulta de los servicios administrados para Prometheus están configuradas a fin de recuperar datos de Monarch mediante la API de Cloud Monitoring. Cuando consultas Monarch en lugar de consultar datos desde servidores locales de Prometheus, obtienes supervisión global a gran escala.
Antes de comenzar
Si aún no implementaste el servicio administrado, configura la colección administrada o la colección autoimplementada. Puedes omitirlo si solo te interesa consultar las métricas de Cloud Monitoring mediante PromQL.
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 Google Cloud:
gcloud config set project PROJECT_ID
Configura la CLI de
kubectlpara 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 NAMESPACE_NAME de Kubernetes para los recursos que crees como parte de la aplicación de ejemplo:
kubectl create ns NAMESPACE_NAME
Verifica las credenciales de la cuenta de servicio
Puedes omitir esta sección si tu clúster de Kubernetes tiene habilitada Workload Identity.
Cuando se ejecuta en GKE, el servicio administrado para Prometheus recupera credenciales de forma automática del entorno en función de la cuenta de servicio predeterminada de Compute Engine. La cuenta de servicio predeterminada tiene los permisos necesarios, monitoring.metricWriter y monitoring.viewer, de forma predeterminada. Si no usas Workload Identity y ya quitaste cualquiera de esas funciones de la cuenta de servicio de nodo predeterminada, tendrás que volver a agregar esos permisos faltantes antes de continuar.
Si no ejecutas en GKE, consulta Proporciona credenciales explícitamente.
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 una cuenta de servicio dedicada de Google Cloud,
gmp-test-sa. - Vincula la cuenta de servicio de Google Cloud a la cuenta de servicio de Kubernetes predeterminada en un espacio de nombres de prueba,
NAMESPACE_NAME. - Otorgar el permiso necesario a la cuenta de servicio de Google Cloud
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 NAMESPACE_NAME:
gcloud config set project PROJECT_ID \ && 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[NAMESPACE_NAME/default]" \ gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \ && kubectl annotate serviceaccount \ --namespace NAMESPACE_NAME \ 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.
Para autorizar tu cuenta de servicio a fin de que lea desde un alcance de métricas de varios proyectos, sigue estas instrucciones y, luego, consulta Cambia el proyecto consultado.gcloud projects add-iam-policy-binding PROJECT_ID \ --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \ --role=roles/monitoring.viewer
Depura la configuración de Workload Identity
Si tienes problemas para lograr que Workload Identity funcione, consulta la documentación a fin de verificar la configuración de Workload Identity y la Guía de solución de problemas de Workload Identity.
Como los errores tipográficos y de copia parcial son las fuentes de errores más comunes en la configuración de Workload Identity, recomendamos usar las variables editables y los íconos de copiar y pegar en los que se puede hacer clic incorporados en las muestras de código de estas instrucciones.
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.
El alcance de las métricas de Monitoring es una construcción de solo lectura que te permite consultar datos de métricas que pertenecen a varios proyectos de Google Cloud. Cada permiso de métricas está alojado en un proyecto de Google Cloud designado, llamado proyecto de 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 de permisos puede tener más de un proyecto supervisado en su permiso, y las métricas y configuraciones de todos los proyectos supervisados en el alcance de las métricas son visibles para el proyecto de permisos. Un proyecto supervisado también puede pertenecer a más de un permiso de métricas.
Cuando consultas las métricas de un proyecto de permisos y si ese proyecto aloja un permiso de métricas de varios proyectos, puedes recuperar datos de varios proyectos. Si tu permiso de métricas contiene todos tus proyectos, tus consultas y reglas se evalúan a nivel global.
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 un permiso de métricas de varios proyectos, consulta Visualiza métricas de varios proyectos.
Datos de Managed Service para Prometheus en Cloud Monitoring
La forma más sencilla de comprobar que se exportan los datos de Prometheus es usar la página del Explorador de métricas de Cloud Monitoring en la consola de Google Cloud, que admite PromQL. Para obtener instrucciones, visita Consulta mediante PromQL en Cloud Monitoring.
IU independiente del frontend de Prometheus
Puedes usar la IU independiente del frontend de Prometheus para acceder y visualizar los datos transferidos. 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 del frontend 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 o el ajuste automático de escala horizontal de Pods mediante la biblioteca prometheus-adapter.
Recomendamos configurar Grafana a fin de visualizar datos del servicio administrado para Prometheus mediante el sincronizador de fuentes de datos. Las instrucciones para configurar Grafana con la IU de frontend de Prometheus independiente se incluyen aquí como referencia para los usuarios que configuraron Grafana antes con este método.
Implementa la IU de frontend
A fin de implementar la IU independiente de frontend de Prometheus para el servicio administrado de Prometheus, ejecuta los siguientes comandos:
Implementa el servicio
frontendy configúralo para consultar el proyecto de permisos del permiso de métricas que elijas:curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.8.2/examples/frontend.yaml | sed 's/\$PROJECT_ID/PROJECT_ID/' | kubectl apply -n NAMESPACE_NAME -f -
Redirecciona los servicios de
frontenda tu máquina local. En el siguiente ejemplo, se reenvía el servicio al puerto 9090:kubectl -n NAMESPACE_NAME 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 independiente del frontend de Prometheus en el espacio de nombres monitoring en su lugar.
Puedes acceder a la IU independiente del frontend de Prometheus en tu navegador con 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 independiente del frontend de Prometheus que muestra la métrica up:
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.
Cambia el proyecto consultado para obtener supervisión de varios proyectos
La implementación frontend usa el proyecto de Google Cloud configurado 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.
Puedes especificar un proyecto con un alcance de métricas de varios proyectos 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
frontendcuá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
defaultde Compute Engine, puedes realizar una de las siguientes acciones:Habilita Workload Identity en tu clúster y sigue los pasos de configuración.
Proporciona una clave de cuenta de servicio explícita.
A fin de otorgar los permisos necesarios para acceder a un proyecto de Google Cloud diferente, haz lo siguiente:
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
Abre la implementación
frontendque creaste antes para editarla:kubectl -n NAMESPACE_NAME edit deploy frontend
Especifica el proyecto de destino con la marca
--query.project-id:apiVersion: apps/v1 kind: Deployment metadata: namespace: NAMESPACE_NAME 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.
Autentica la IU de frontend
La implementación frontend admite la autenticación de acceso básica para el acceso autenticado en las versiones 0.5.0 y posteriores. Para habilitar la autenticación, agrega las variables de entorno AUTH_USERNAME y AUTH_PASSWORD a la implementación:
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: NAMESPACE_NAME
name: frontend
spec:
template
containers:
- name: frontend
env:
- name: AUTH_USERNAME
value: USERNAME
- name: AUTH_PASSWORD
value: PASSWORD
...
Proporciona credenciales de forma explícita
Puedes omitir esta sección si ejecutas el contenedor frontend en
un clúster de Google Kubernetes Engine. Si tienes problemas de autenticación en
GKE, consulta Verifica las credenciales de la cuenta de servicio.
Cuando se ejecuta en GKE, el evaluador de reglas recupera las credenciales del entorno de forma automática según la cuenta de servicio del nodo 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.
Configura el contexto en tu proyecto de destino:
gcloud config set project PROJECT_ID
Crear 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.
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
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
Agrega el archivo de claves como un secreto a tu clúster que no es de GKE:
kubectl -n NAMESPACE_NAME create secret generic gmp-test-sa \ --from-file=key.json=gmp-test-sa-key.json
Abre el recurso de implementación de frontend para editarlo:
kubectl -n NAMESPACE_NAME edit deploy frontend
Agrega el texto que se muestra en negrita al recurso:
apiVersion: apps/v1 kind: Deployment metadata: namespace: NAMESPACE_NAME 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 ...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.
GOOGLE_APPLICATION_CREDENTIALS.Usa Grafana a través del proxy de frontend
El servicio administrado para Prometheus usa la fuente de datos integrada de Prometheus para Grafana, lo que significa que puedes seguir usando cualquier panel de Grafana creado por la comunidad o personal sin ningún cambio. También puedes importar tus paneles de Grafana a Cloud Monitoring.
Autentica las API de Google Cloud
Todas las API de Google Cloud requieren autenticación mediante OAuth2; Sin embargo, Grafana no admite la autenticación de OAuth2 para las fuentes de datos de Prometheus. Si deseas usar Grafana con el servicio administrado para Prometheus, usa la IU independiente del frontend de Prometheus como un proxy de autenticación.
Debes apuntar a Grafana al proxy de la IU independiente de frontend para consultar datos a nivel global. Si no sigues estos pasos, Grafana solo ejecuta consultas en los datos del servidor de Prometheus local.
Si aún no implementaste el servicio de
frontendde la IU de Prometheus como un proxy, impleméntalo ahora mediante la ejecución del siguiente comando:curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.8.2/examples/frontend.yaml | sed 's/\$PROJECT_ID/PROJECT_ID/' | kubectl apply -n NAMESPACE_NAME -f -
En el caso de los clústeres de Kubernetes que no son de GKE, como los clústeres de Anthos, también consulta Proporciona credenciales de forma explícita para otorgar al servicio
frontendlos permisos necesarios para consultar las métricas.Consulta Cambia el proyecto consultado si deseas obtener instrucciones para configurar el permiso de las métricas que usa el servicio
frontenda fin de realizar consultas en varios proyectos.Si tienes una implementación de Grafana preexistente, como una instalada por la biblioteca
kube-prometheuso una instalada mediante un gráfico de helm, puedes continuar usándola con el Service administrado para Prometheus. Si es así, consulta Configura una fuente de datos para conocer los próximos pasos. De lo contrario, primero debes implementar Grafana.Implementa Grafana
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.yamldel servicio administrado para Prometheus a tu clúster y redirecciona el serviciografanaa tu máquina local. En el siguiente ejemplo, se reenvía el servicio al puerto 3000.Aplica el manifiesto
grafana.yaml:kubectl -n NAMESPACE_NAME apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/beb779d32f4dd531a3faad9f2916617b8d9baefd/examples/grafana.yaml
Redirecciona los servicios de
grafanaa tu máquina local. En este ejemplo, se reenvía el servicio al puerto 3000:kubectl -n NAMESPACE_NAME 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:3000con el nombre de usuario: contraseñaadmin:admin.
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:
Ve a la implementación de Grafana, por ejemplo, si navegas a la URL
http://localhost:3000para llegar a la página de bienvenida de Grafana.Selecciona Configuración en el menú principal de Grafana y, luego, selecciona Fuentes de datos.
Selecciona Agregar fuente de datos (Add data source) y selecciona Prometheus como la base de datos de series temporales.
En el campo URL del panel HTTP, ingresa la URL del servicio administrado para el servicio
frontendde Prometheus. Si configuraste la IU de frontend de Prometheus para que se ejecute en el puerto 9090, la URL del servicio de este campo eshttp://frontend.NAMESPACE_NAME.svc:9090.En el campo Tiempo de espera del panel HTTP, establece el valor en
120.Si configuras el proxy de IU de frontend con autenticación básica, habilita losAutenticación básica cambiar enAuth y complete el nombre de usuario y la contraseña.
En el campo Tiempo de espera de la consulta, establece el valor en
2m.En el campo Método HTTP, selecciona
GET.En el campo Tipo de Prometheus, selecciona
Prometheus.En el campo Versión de Prometheus, selecciona
2.40.xo una versión superior.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.
Haz clic en Guardar y probar y busca el mensaje “La fuente de datos funciona”.
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:
Conecta el servicio administrado para Prometheus a Thanos
Puedes federar el servicio administrado para Prometheus en una pila de Thanos autoimplementada mediante el thanos-promql-connector de código abierto. Google Cloud no ofrece asistencia para esta integración.
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_IDes 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"] }] } }Para obtener información sobre cómo consultar las métricas del sistema de Google Cloud mediante PromQL, consulta PromQL para las métricas de Cloud Monitoring.
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/.Para obtener la documentación completa, consulta la documentación de referencia de la API de Cloud Monitoring.
Para obtener información sobre la compatibilidad con PromQL, consulta Compatibilidad con PromQL.
Los siguientes extremos son totalmente compatibles:
/api/v1/query/api/v1/query_range/api/v1/metadata/api/v1/labels/api/v1/query_exemplars
El extremo
/api/v1/label/<label_name>/valuessolo funciona si la etiqueta__name__se proporciona mediante el uso del valor<label_name>o mediante la coincidencia exacta con un selector de serie. Por ejemplo, las siguientes llamadas son totalmente compatibles:/api/v1/label/__name__/values/api/v1/label/__name__/values?match[]={__name__=~".*metricname.*"}/api/v1/label/labelname/values?match[]={__name__="metricname"}
Esta limitación hace que las consultas variables de
label_values($label)en Grafana fallen. En su lugar, puedes usarlabel_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/serieses compatible con solicitudesGET, pero no conPOST. Cuando usas el sincronizador de fuentes de datos o el proxy de frontend, esta restricción se administra por ti. También puedes configurar las fuentes de datos de Prometheus en Grafana para emitir solo solicitudesGET.