Utiliser l'agent Ops sur Compute Engine

Ce document décrit la configuration et l'utilisation d'un récepteur de métriques de l'agent Ops que vous pouvez utiliser pour collecter des métriques à partir de Prometheus sur Compute Engine. Ce document décrit également un exemple que vous pouvez utiliser pour tester le récepteur.

Les utilisateurs de Google Kubernetes Engine ont pu collecter des métriques Prometheus à l'aide de Google Cloud Managed Service pour Prometheus. Le récepteur Prometheus de l'agent Ops offre la même capacité aux utilisateurs de Compute Engine.

Vous pouvez utiliser tous les outils fournis par Cloud Monitoring, y compris PromQL, pour afficher et analyser les données collectées par le récepteur Prometheus. Par exemple, vous pouvez utiliser l'explorateur de métriques, comme décrit dans la section console Google Cloud pour Monitoring, pour interroger vos données. Vous pouvez également créer des tableaux de bord et des règles d'alerte Cloud Monitoring pour surveiller vos métriques Prometheus. Nous vous recommandons d'utiliser PromQL comme langage de requête pour vos métriques Prometheus.

Vous pouvez également afficher vos métriques Prometheus dans des interfaces extérieures à Cloud Monitoring, telles que l'interface utilisateur Prometheus et Grafana.

Choisir le bon récepteur

Avant de décider d'utiliser le récepteur Prometheus, déterminez s'il existe déjà une intégration de l'agent Ops pour l'application que vous utilisez. Pour en savoir plus sur les intégrations existantes avec l'agent Ops, consultez la section Surveiller des applications tierces. Si une intégration existe déjà, nous vous recommandons de l'utiliser. Pour en savoir plus, consultez la section Choisir une intégration existante.

Nous vous recommandons d'utiliser le récepteur Prometheus de l'agent Ops lorsque les conditions suivantes sont remplies :

Vous avez l'habitude d'utiliser Prometheus, vous vous basez sur la norme Prometheus et vous comprenez comment des facteurs tels que l'intervalle de scraping et la cardinalité peuvent affecter vos coûts. Pour en savoir plus, consultez la section Choisir le récepteur Prometheus.
Le logiciel que vous surveillez ne fait pas déjà partie de l'ensemble des intégrations existantes de l'agent Ops.

Intégrations existantes

L'agent Ops fournit des intégrations pour un certain nombre d'applications tierces. Ces intégrations vous offrent les avantages suivants :

Un ensemble de métriques workload.googleapis.com sélectionnées pour l'application
Un tableau de bord permettant de visualiser les métriques.

Les métriques ingérées en utilisant une intégration existante sont soumises à une tarification par octets pour les métriques collectées par l'agent. Le nombre et les types de métriques sont connus à l'avance. Vous pouvez utiliser ces informations pour estimer les coûts.

Par exemple, si vous utilisez l'intégration Apache Web Server (httpd), l'agent Ops collecte cinq métriques scalaires. Chaque point de données compte pour 8 octets. Si vous conservez la fréquence d'échantillonnage par défaut de l'agent Ops de 60 secondes, le nombre d'octets ingérés par jour est de 57 600 multiplié par le nombre d'hôtes :

8 (octets) x 1440 (minutes par jour) x 5 (métriques) x n (hôtes), ou
57 600 x n (hôtes)

Pour en savoir plus sur l'estimation des coûts, consultez la section Exemples de tarification basés sur les octets ingérés.

Récepteur Prometheus

Lorsque vous utilisez l'agent Ops pour collecter des métriques Prometheus, les critères suivants s'appliquent :

Le nombre et la cardinalité des métriques émises par votre application sont sous votre contrôle. Il n'existe pas d'ensemble organisé de métriques. La quantité de données que vous ingérez est déterminée par la configuration de votre application Prometheus et du récepteur Prometheus de l'agent Ops.
Les métriques sont ingérées dans Cloud Monitoring en tant que métriques prometheus.googleapis.com. Ces métriques sont classées en tant que type de métriques "personnalisées" lorsqu'elles sont ingérées dans Cloud Monitoring et sont soumises aux quotas et limites des métriques personnalisées.
Vous devez concevoir et créer les tableaux de bord Cloud Monitoring dont vous avez besoin en fonction de l'ensemble de métriques que vous ingérez et de vos besoins commerciaux. Pour en savoir plus sur la création des tableaux de bord, consultez la section Tableaux de bord et graphiques.
Les tarifs appliqués pour l'ingestion des métriques sont basés sur le nombre d'échantillons ingérés. Pour estimer vos coûts lorsque vous utilisez le récepteur Prometheus, vous devez déterminer le nombre d'échantillons que vous êtes susceptible de collecter au cours d'un cycle de facturation. Cette estimation est basée sur les facteurs suivants :
- Nombre de métriques scalaires. Chaque valeur est un échantillon.
- Nombre de métriques de distribution. Chaque histogramme compte pour des échantillons (2 + le nombre de buckets dans l'histogramme).
- Fréquence d'échantillonnage de chaque métrique.
- Nombre d'hôtes à partir desquels les métriques sont échantillonnées.
Pour en savoir plus sur le comptage des échantillons et l'estimation des coûts, consultez la section Exemples de tarification basés sur les échantillons ingérés.

Prérequis

Pour collecter des métriques Prometheus à l'aide du récepteur Prometheus, vous devez installer l'agent Ops version 2.25.0 ou ultérieure.

Le récepteur de l'agent Ops nécessite un point de terminaison qui émet des métriques Prometheus. Par conséquent, votre application doit fournir directement ce point de terminaison, ou utiliser une bibliothèque ou un exportateur Prometheus pour exposer un point de terminaison. De nombreuses bibliothèques et frameworks de langages tels que Spring et DropWizard, ou des applications telles que StatsD, DogStatsD et Graphite, qui émettent des métriques non Prometheus, peuvent utiliser des bibliothèques clientes ou des exportateurs Prometheus pour émettre des métriques de type Prometheus. Par exemple, pour émettre des métriques Prometheus :

Les utilisateurs de Spring peuvent utiliser la bibliothèque de Métriques Spring.
Les utilisateurs de StatsD peuvent utiliser le package statsd_exporter.
Les utilisateurs de Graphite peuvent utiliser le package graphite_exporter.

Lorsque les métriques Prometheus sont émises par une application, directement ou par le biais d'une bibliothèque ou d'un exportateur, elles peuvent être collectées par un agent Ops configuré avec un récepteur Prometheus.

Configurer l'agent Ops

Le modèle de configuration de l'agent Ops implique généralement de définir les éléments suivants :

Les récepteurs, qui déterminent les métriques collectées.
Les processeurs, qui décrivent comment l'agent Ops peut modifier les métriques
Les pipelines, qui associent les récepteurs et les processeurs dans un service.

La configuration pour l'ingestion de métriques Prometheus est légèrement différente : aucun processeur n'est impliqué.

Configuration pour les métriques Prometheus

La configuration de l'agent Ops pour l'ingestion de métriques Prometheus diffère de la configuration habituelle :

Vous ne créez pas de processeur d'agent Ops pour les métriques Prometheus. Le récepteur Prometheus prend en charge presque toutes les options de configuration spécifiées par la spécification scrape_config de Prometheus, y compris les options de réécriture de libellés.

Au lieu d'utiliser un processeur d'agent Ops, le traitement des métriques est effectué à l'aide des sections relabel_configs et metric_relabel_configs de la configuration de scraping, comme spécifié dans le récepteur Prometheus. Pour en savoir plus, consultez la section Réécriture de libellés : modifier les données scrapées.
Vous définissez le pipeline Prometheus en fonction du récepteur Prometheus uniquement. Vous ne spécifiez aucun processeur. Vous ne pouvez pas non plus utiliser des récepteurs non Prometheus dans le pipeline pour les métriques Prometheus.

La majeure partie de la configuration du récepteur repose sur la spécification des options de configuration de scraping. Si vous omettez ces options par souci de concision, l'exemple suivant montre la structure d'une configuration de l'agent Ops utilisant un récepteur Prometheus. Vous spécifiez les valeurs de RECEIVER_ID et PIPELINE_ID.

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

  service:
    pipelines:
      PIPELINE_ID:
        receivers: [RECEIVER_ID]

La section suivante décrit plus en détail le récepteur Prometheus. Pour obtenir un exemple fonctionnel de récepteur et de pipeline, consultez la section Ajouter le récepteur et le pipeline de l'agent Ops.

Récepteur Prometheus

Pour spécifier un récepteur pour les métriques Prometheus, vous devez créer un récepteur de métriques de type prometheus et spécifier un ensemble d'options scrape_config. Le récepteur accepte toutes les options scrape_config de Prometheus, à l'exception des suivantes :

Les sections de détection de services, *_sd_config.
Le paramètre honor_labels.

Par conséquent, vous pouvez copier les configurations de scraping existantes et les utiliser pour l'agent Ops sans aucune ou très peu de modifications.

La structure complète du récepteur Prometheus est illustrée ci-dessous :

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

Pour obtenir des exemples de configurations de réécriture de libellés, consultez la section Configuration supplémentaire du récepteur.

Exemple : Configurer l'agent Ops pour Prometheus

Cette section présente un exemple de configuration de l'agent Ops pour collecter les métriques Prometheus d'une application. Cet exemple utilise l'exportateur JSON fourni par la communauté Prometheus (json_exporter), qui expose les métriques Prometheus sur le port 7979.

La configuration de l'exemple nécessite les ressources suivantes, que vous devrez peut-être installer :

git
curl
make
python3
Langage Go, version 1.19 ou ultérieure

Créer ou configurer votre application

Pour obtenir et exécuter l'exportateur JSON, procédez comme suit :

Clonez le dépôt json_exporter et vérifiez l'exportateur en exécutant les commandes suivantes :

git clone https://github.com/prometheus-community/json_exporter.git

cd json_exporter

git checkout v0.5.0

Compilez l'exportateur en exécutant la commande suivante :
```
make build
```
Démarrez le serveur HTTP Python en exécutant la commande suivante :
```
python3 -m http.server 8000 &
```
Démarrez l'exportateur JSON en exécutant la commande suivante :
```
./json_exporter --config.file examples/config.yml &
```

Interrogez l'exportateur JSON pour vérifier qu'il est en cours d'exécution et qu'il expose les métriques sur le port 7979 :

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

Si la requête aboutit, un résultat semblable à celui-ci s'affiche :

# 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

Dans ce résultat, les chaînes telles que example_value_active sont les noms des métriques, avec des étiquettes et des valeurs entre accolades. La valeur des données suit l'ensemble de libellés.

Ajouter le récepteur et le pipeline de l'agent Ops

Pour configurer l'agent Ops de façon à ingérer les métriques à partir de l'application d'exportation JSON, vous devez modifier la configuration de l'agent pour ajouter un récepteur et un pipeline Prometheus. Pour l'exemple de l'exportateur JSON, procédez comme suit :

Modifiez le fichier de configuration de l'agent Ops, /etc/google-cloud-ops-agent/config.yaml, et ajoutez les entrées de récepteur et de pipeline Prometheus suivantes :
```
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 vous disposez déjà d'autres entrées de configuration dans ce fichier, ajoutez le récepteur et le pipeline Prometheus aux entrées metrics et service existantes. Pour en savoir plus, consultez la section Configuration des métriques.

Pour obtenir des exemples de réécriture des libellés de configurations dans le récepteur, consultez la section Configuration supplémentaire du récepteur.

Redémarrer l'agent Ops

Pour appliquer vos modifications de configuration, vous devez redémarrer l'agent Ops.

LINUX

Pour redémarrer l'agent, exécutez la commande suivante sur votre instance :
```
sudo service google-cloud-ops-agent restart
```
Pour vérifier que l'agent a redémarré, exécutez la commande suivante et vérifiez que les composants "Agent de métriques" et "Agent de journalisation" ont démarré :
```
sudo systemctl status google-cloud-ops-agent"*"
```

Windows

Connectez-vous à votre instance via RDP ou un outil similaire, et connectez-vous à Windows.
Ouvrez un terminal PowerShell avec des droits d'administrateur en effectuant un clic droit sur l'icône PowerShell, puis en sélectionnant Exécuter en tant qu'administrateur.
Pour redémarrer l'agent, exécutez la commande PowerShell suivante :
```
Restart-Service google-cloud-ops-agent -Force
```
Pour vérifier que l'agent a redémarré, exécutez la commande suivante et vérifiez que les composants "Agent de métriques" et "Agent de journalisation" ont démarré :
```
Get-Service google-cloud-ops-agent*
```

Métriques Prometheus dans Cloud Monitoring

Vous pouvez utiliser les outils fournis par Cloud Monitoring avec les données collectées par le récepteur Prometheus. Par exemple, vous pouvez représenter les données à l'aide de l'Explorateur de métriques, comme décrit dans la section console Google Cloud pour Monitoring. Les sections suivantes décrivent les outils de requête disponibles dans Cloud Monitoring avec l'explorateur de métriques :

Vous pouvez créer des tableaux de bord et des règles d'alerte Cloud Monitoring pour vos métriques. Pour en savoir plus sur les tableaux de bord et les types de graphiques que vous pouvez utiliser, consultez la section Tableaux de bord et graphiques. Pour en savoir plus sur les règles d'alerte, consultez la section Utiliser des règles d'alerte.

Vous pouvez également afficher vos métriques dans d'autres interfaces, telles que l'interface utilisateur de Prometheus et Grafana. Pour en savoir plus concernant la configuration de ces interfaces, consultez les sections suivantes dans la documentation sur Google Cloud Managed Service pour Prometheus :

Utiliser PromQL

PromQL est le langage de requête recommandé pour les métriques ingérées à l'aide du récepteur Prometheus.

Le moyen le plus simple de vérifier que vos données Prometheus sont ingérées consiste à utiliser la page de l'Explorateur de métriques Cloud Monitoring dans la console Google Cloud :

Dans la console Google Cloud, accédez à la page Explorateur de métriques :
Accéder à l'explorateur de métriques

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
Dans la barre d'outils du volet de création de requêtes, sélectionnez le bouton nommé MQL ou PromQL.
Vérifiez que PromQL est sélectionné dans le bouton d'activation Langage. Le bouton de langage se trouve dans la barre d'outils qui vous permet de mettre en forme votre requête.
Saisissez la requête suivante dans l'éditeur, puis cliquez sur Exécuter la requête :
```
up
```

Si vos données sont ingérées, un graphique semblable à celui-ci s'affiche :

Graphique de l'explorateur de métriques pour la métrique "up" de "json-exporter".

Si vous exécutez l'exemple d'exportateur JSON, vous pouvez également émettre des requêtes telles que les suivantes :

Interroger toutes les données pour une métrique exportée spécifique par nom, par exemple :
```
example_value_count
```
L'exemple ci-dessous présente un graphique pour example_value_count, y compris les libellés définis par l'application d'exportation JSON et les libellés ajoutés par l'agent Ops :
Interroger les données pour une métrique exportée qui provient d'un espace de noms spécifique. La valeur du libellé namespace est l'ID d'instance Compute Engine, un nombre long tel que 5671897148133813325, attribué à la VM. Une requête se présente comme suit :
```
example_value_count{namespace="INSTANCE_ID"}
```
Interroger les données qui correspondent à une expression régulière spécifique. L'exportateur JSON émet des métriques avec un libellé id comprenant des valeurs telles que id-A, id-B et id-C. Pour filtrer toutes les métriques dont le libellé id correspond à ce modèle, utilisez la requête suivante :
```
example_value_count{id=~"id.*"}
```

Pour en savoir plus sur l'utilisation de PromQL dans les graphiques de l'explorateur de métriques et de Cloud Monitoring, consultez la page PromQL dans Cloud Monitoring.

Utiliser MQL

Pour afficher vos données Prometheus en tant que séries temporelles Cloud Monitoring et pour créer des graphiques et des tableaux de bord, vous pouvez également utiliser les interfaces basées sur des menus ou le langage MQL. Voici une requête simple dans l'explorateur de métriques :

Dans la console Google Cloud, accédez à la page Explorateur de métriques :
Accéder à l'explorateur de métriques

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
Spécifiez les données que vous souhaitez faire apparaître dans le graphique. En plus d'utiliser l'onglet PromQL décrit précédemment, vous pouvez également utiliser MQL.
- Pour utiliser MQL, procédez comme suit :
  1. Dans la barre d'outils du volet de création de requêtes, sélectionnez le bouton nommé MQL ou PromQL.
  2. Vérifiez que MQL est sélectionné dans le bouton d'activation Langage. Le bouton de langage se trouve dans la barre d'outils qui vous permet de mettre en forme votre requête.
  3. Saisissez la requête suivante :
```
fetch prometheus_target::prometheus.googleapis.com/up/gauge
```
  4. Cliquez sur Exécuter la requête (Run Query).
- Pour utiliser l'interface basée sur un menu, procédez comme suit :
  1. Dans le champ Resource type (Type de ressource), saisissez "prometheus" pour filtrer la liste, puis sélectionnez Prometheus Target (Cible Prometheus).
  2. Dans le champ Metric (Métrique), saisissez "up/" pour filtrer la liste, puis sélectionnez prometheus/up/gauge.

Le graphique résultant de l'une de ces requêtes affiche les mêmes données que le graphique présenté avec l'exemple PromQL.

Ressource `prometheus_target`

Dans Cloud Monitoring, les données de séries temporelles sont écrites par rapport à un type de ressource surveillée. Pour les métriques Prometheus, le type de ressource surveillée est prometheus_target. Les requêtes de surveillance pour les métriques Prometheus qui ne sont pas écrites dans PromQL doivent spécifier ce type de ressource.

La ressource prometheus_target possède les libellés suivants, que vous pouvez utiliser pour filtrer et manipuler les données interrogées :

project_id : identifiant du projet Google Cloud, tel que my-project, dans lequel l'agent Ops s'exécute.
location : région Google Cloud ou AWS dans laquelle l'agent Ops s'exécute. Par exemple, us-east1-a (Google Cloud) ou aws:us-east-1a (AWS).
cluster : toujours __gce__ pour les métriques Prometheus collectées à l'aide de l'agent Ops.
namespace : ID d'instance Compute Engine de la VM sur laquelle l'agent Ops s'exécute.
job : valeur du champ job_name dans la configuration du récepteur.
instance : libellé d'instance de la cible Prometheus, issu de la configuration du récepteur. La valeur par défaut est la cible.

Les valeurs de ces libellés sont définies lors de la collecte. Les valeurs des libellés namespace, location et cluster sont immuables. Si les métriques scrapées depuis votre application possèdent également ces libellés, l'agent Ops ajoute un préfixe aux libellés scrapés avec la chaîne exported_.

Afficher les données d'utilisation et de diagnostic des métriques dans Cloud Monitoring

La page Gestion des métriques de Cloud Monitoring fournit des informations qui peuvent vous aider à contrôler les sommes que vous consacrez aux métriques facturables, sans affecter l'observabilité. La page Gestion des métriques fournit les informations suivantes :

Les volumes d'ingestion pour la facturation à base d'octets et celle à base d'exemples, englobant les différents domaines de métriques et des métriques individuelles
Les données sur les libellés et la cardinalité des métriques
Nombre de lectures pour chaque métrique.
L'utilisation de métriques dans les règles d'alerte et les tableaux de bord personnalisés
Les taux d'erreurs d'écriture de métriques

Vous pouvez également utiliser la gestion des métriques pour exclure les métriques inutiles, ce qui élimine le coût de leur ingestion.

Procédez comme suit pour afficher la page Gestion des métriques :

Dans la console Google Cloud, accédez à la page Gestion des métriques :
Accédez à la page Gestion des métriques

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
Dans la barre d'outils, sélectionnez votre période. Par défaut, la page Gestion des métriques affiche des informations sur les métriques collectées au cours du jour précédent.

Pour en savoir plus sur la page Gestion des métriques, consultez la section Afficher et gérer l'utilisation des métriques.

Réécriture de libellés : modifier les données scrapées

Vous pouvez utiliser la réécriture de libellés pour modifier l'ensemble de libellés de la cible de scraping ou de ses métriques avant que la cible ne soit scrapée. Si vous avez plusieurs étapes dans une configuration de réécriture de libellés, elles sont appliquées dans l'ordre dans lequel elles apparaissent dans le fichier de configuration.

L'agent Ops crée un ensemble de méta-libellés (libellés précédés de la chaîne __meta_). Ces méta-libellés enregistrent des informations concernant l'instance Compute Engine sur laquelle l'agent Ops est exécuté. Les libellés précédés de la chaîne __, y compris les méta-libellés, ne sont disponibles que lors de la réécriture des libellés. Vous pouvez utiliser la réécriture de libellés pour capturer les valeurs de ces libellés dans les libellés scrapés.

La réécriture des libellés de métriques est appliquée aux échantillons. Il s'agit de la dernière étape avant l'ingestion. Vous pouvez utiliser la réécriture des libellés de métriques pour ignorer des séries temporelles que vous n'avez pas besoin d'ingérer. La non-prise en compte de ces séries temporelles réduit le nombre d'échantillons ingérés, ce qui peut réduire les coûts.

Pour en savoir plus sur la réécriture de libellés, consultez la documentation Prometheus pour relabel_config et metric_relabel_configs.

Méta-libellés Compute Engine disponibles lors de la réécriture de libellés

Lorsque l'agent Ops scrape les métriques, il inclut un ensemble de méta-libellés dont les valeurs sont basées sur la configuration de la VM Compute Engine sur laquelle l'agent s'exécute. Vous pouvez utiliser ces libellés et la section relabel_configs du récepteur Prometheus pour ajouter des métadonnées supplémentaires à vos métriques sur la VM à partir de laquelle elles ont été ingérées. Pour obtenir un exemple, consultez la section Configuration supplémentaire du récepteur.

Les méta-libellés suivants sont disponibles sur les cibles que vous pouvez utiliser dans la section relabel_configs :

__meta_gce_instance_id : ID numérique de l'instance Compute Engine (locale).
__meta_gce_instance_name : nom de l'instance Compute Engine (locale). L'agent Ops place automatiquement cette valeur dans le libellé instance_name modifiable sur vos métriques.
__meta_gce_machine_type : URL complète ou partielle du type de machine de l'instance. L'agent Ops place automatiquement cette valeur dans le libellé machine_type modifiable sur vos métriques.
__meta_gce_metadata_NAME : chaque élément de métadonnées de l'instance.
__meta_gce_network : URL du réseau de l'instance.
__meta_gce_private_ip : adresse IP privée de l'instance.
__meta_gce_interface_ipv4_NAME : adresse IPv4 de chaque interface nommée.
__meta_gce_project : projet Google Cloud dans lequel l'instance est exécutée (locale).
__meta_gce_public_ip : adresse IP publique de l'instance, le cas échéant.
__meta_gce_tags : liste de tags d'instances séparés par une virgule.
__meta_gce_zone : URL de la zone Compute Engine dans laquelle l'instance est exécutée.

Les valeurs de ces libellés sont définies au démarrage de l'agent Ops. Si vous modifiez les valeurs, vous devez redémarrer l'agent Ops pour les actualiser.

Configuration supplémentaire du récepteur

Cette section fournit des exemples qui utilisent les sections relabel_configs et metric_relabel_configs du récepteur Prometheus pour modifier le nombre et la structure des métriques ingérées. Cette section inclut également une version modifiée du récepteur pour l'exemple d'exportateur JSON qui utilise les options de réécriture des libellés.

Ajouter des métadonnées de VM

Vous pouvez utiliser la section relabel_configs pour ajouter des libellés aux métriques. Par exemple, la commande suivante utilise un méta-libellé, __meta_gce_zone, fourni par l'agent Ops pour créer un libellé de métrique, zone, qui est conservé après la réécriture de libellé car zone ne possède pas le préfixe __.

Pour obtenir la liste des méta-libellés disponibles, consultez la section Méta-libellés Compute Engine disponibles lors de la réécriture de libellés. Certains méta-libellés sont réécrits automatiquement par la configuration par défaut de l'agent Ops.

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

Le récepteur Prometheus présenté dans la section Exemple : Configurer l'agent Ops pour Prometheus inclut l'ajout de ce libellé.

Supprimer des métriques

Vous pouvez utiliser la section metrics_relabel_configs pour ignorer les métriques que vous ne souhaitez pas ingérer. Ce modèle est utile pour maîtriser les coûts. Par exemple, vous pouvez utiliser le modèle suivant pour ignorer toute métrique dont le nom correspond à METRIC_NAME_REGEX_1 ou METRIC_NAME_REGEX_2 :

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

Ajouter des libellés statiques

Vous pouvez utiliser la section metrics_relabel_configs pour ajouter des libellés statiques à toutes les métriques ingérées par le récepteur Prometheus. Vous pouvez utiliser le modèle suivant pour ajouter les libellés staticLabel1 et staticLabel2 à toutes les métriques ingérées :

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 version du récepteur Prometheus présentée ci-dessous pour l'exemple de l'exportateur JSON utilise ces modèles de configuration pour effectuer les opérations suivantes :

Définir le libellé zone à partir de la valeur du méta-libellé __meta_gce_zone fourni par l'agent Ops.
Supprimer la métrique example_global_value de l'exportateur.
Ajouter le libellé staticLabel avec la valeur "Valeur statique" à toutes les métriques ingérées.

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

Utiliser l'agent Ops sur Compute Engine

Choisir le bon récepteur

Intégrations existantes

Récepteur Prometheus

Prérequis

Configurer l'agent Ops

Configuration pour les métriques Prometheus

Récepteur Prometheus

Exemple : Configurer l'agent Ops pour Prometheus

Créer ou configurer votre application

Ajouter le récepteur et le pipeline de l'agent Ops

Redémarrer l'agent Ops

LINUX

Windows

Métriques Prometheus dans Cloud Monitoring

Utiliser PromQL

Utiliser MQL

Ressource prometheus_target

Afficher les données d'utilisation et de diagnostic des métriques dans Cloud Monitoring

Réécriture de libellés : modifier les données scrapées

Méta-libellés Compute Engine disponibles lors de la réécriture de libellés

Configuration supplémentaire du récepteur

Ajouter des métadonnées de VM

Supprimer des métriques

Ajouter des libellés statiques

Ressource `prometheus_target`