Realiza consultas mediante la IU o la API de Prometheus

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 kubectl para usar tu clúster:
```
kubectl config set-cluster CLUSTER_NAME
```
Para obtener más información sobre estas herramientas, consulta lo siguiente:
- Descripción general de la CLI de gcloud
- Comandos de kubectl

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 habilitado Workload Identity Federation for GKE.

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 Federation for GKE y ya quitaste cualquiera de esos roles 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 Federation for GKE

Puedes omitir esta sección si tu clúster de Kubernetes no tiene habilitado Workload Identity Federation for GKE.

El servicio administrado para Prometheus captura datos de métricas mediante la API de Cloud Monitoring. Si tu clúster usa Workload Identity Federation for GKE, 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 Federation for GKE

Si tienes problemas para lograr que Workload Identity Federation for GKE funcione, consulta la documentación para verificar la configuración de Workload Identity Federation for GKE y la Guía de solución de problemas de la federación de Workload Identity Federation for GKE.

Como los errores tipográficos y de copia parcial son las fuentes de errores más comunes en la configuración de Workload Identity Federation for GKE, 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 Federation for GKE 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 Workload Identity, consulta Usa Workload Identity Federation for GKE.

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 con 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 función se puede usar en herramientas cliente que no son compatibles con OAuth2 para las cuentas de servicio, incluido Grafana o el ajuste automático de escala horizontal de Pods a través de la biblioteca prometheus-adapter.

Recomendamos configurar Grafana para visualizar datos del servicio administrado para Prometheus a través del sincronizador de fuente de datos. Las instrucciones para configurar Grafana a través de la IU independiente del frontend de Prometheus se incluyen aquí como referencia para los usuarios que configuraron Grafana 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 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.13.0/examples/frontend.yaml |
sed 's/\$PROJECT_ID/PROJECT_ID/' |
kubectl apply -n NAMESPACE_NAME -f -

Redirecciona los servicios de frontend a 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:

Visualiza una métrica en la interfaz 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.

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 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:
- Habilita Workload Identity Federation for GKE 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 frontend que 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 de 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 frontend recupera de forma automática las credenciales del entorno según la cuenta de servicio del nodo o la configuración de Workload Identity Federation for GKE. 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 Federation for GKE.

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
```
1. 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
...
```
2. 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.
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

Advertencia: Recomendamos configurar Grafana para visualizar datos del servicio administrado para Prometheus a través del sincronizador de fuente de datos. Estas instrucciones para configurar Grafana a través de la IU independiente del frontend de Prometheus se incluyen aquí como referencia para los usuarios que configuraron Grafana con este método.

Todas las APIs de Google Cloud requieren autenticación a través de OAuth2. Sin embargo, Grafana no admite la autenticación de OAuth2 para cuentas de servicio que se usan con 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 local de Prometheus.

Si aún no implementaste el servicio de frontend de 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.13.0/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 frontend los 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 frontend a fin de realizar consultas en varios proyectos.

Si tienes una implementación de Grafana preexistente, como una instalada por la biblioteca kube-prometheus o 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.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 NAMESPACE_NAME apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/beb779d32f4dd531a3faad9f2916617b8d9baefd/examples/grafana.yaml
```
2. Redirecciona los servicios de grafana a 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:3000 con el nombre de usuario: contraseña admin: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:
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.
3. Selecciona Agregar fuente de datos (Add data source) y selecciona Prometheus como la base de datos de series temporales.
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 frontend de Prometheus para que se ejecute en el puerto 9090, la URL del servicio de este campo es http://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.x o 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.
5. Haz clic en Guardar y probar y busca el mensaje “La fuente de datos funciona”.
Nota: También puedes implementar el contenedor frontend como un archivo adicional en el Pod de Grafana y esa fuente de datos pueda acceder a él en la URL http://localhost:9090.

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_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"]
    }]
  }
}
```
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. Los extremos HTTP de Promethus no están disponibles en las bibliotecas cliente específicas de un lenguaje 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>/values solo 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 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 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 solicitudes GET. El parámetro match[] no admite la coincidencia de expresiones regulares en la etiqueta __name__.