Évaluation des règles gérées et alertes

Le service géré Google Cloud pour Prometheus est compatible avec l'évaluation des règles compatibles avec Prometheus ainsi qu'avec les alertes. Ce document explique comment configurer l'évaluation des règles gérées.

Évaluation des règles

Managed Service pour Prometheus fournit un composant évaluateur de règle qui vous permet d'écrire des règles en toute sécurité dans le contexte d'un backend global Prometheus, ce qui vous évite d'interférer avec les données d'autres utilisateurs dans les grandes organisations. Le composant est automatiquement déployé dans le cadre d'une collection gérée lors de l'exécution sur des clusters Kubernetes.

Vous pouvez écrire des règles et des alertes concernant à la fois des métriques Managed Service pour Prometheus et des métriques Cloud Monitoring. Lorsque vous écrivez des règles concernant des métriques Cloud Monitoring, vous devez utiliser la ressource GlobalRules.

Règles

L'évaluateur de règle gérée utilise la ressource Règles pour configurer l'enregistrement et les règles d'alerte. Voici un exemple de ressource Règles :

apiVersion: monitoring.googleapis.com/v1
kind: Rules
metadata:
  namespace: NAMESPACE_NAME
  name: example-rules
spec:
  groups:
  - name: example
    interval: 30s
    rules:
    - record: job:up:sum
      expr: sum without(instance) (up)
    - alert: AlwaysFiring
      expr: vector(1)

Le format de l'élément .spec.groups est identique au tableau Prometheus rule_group en amont. Les règles d'alerte et d'enregistrement définies dans Rules sont limitées à project_id, cluster et namespace de la ressource. Par exemple, la règle job:up:sum de la ressource ci-dessus interroge efficacement sum without(instance) (up{project_id="test-project", cluster="test-cluster", namespace="NAMESPACE_NAME"}). Cette garantie empêche les règles d'alerte ou d'enregistrement d'évaluer accidentellement les métriques d'applications que vous ne connaissez peut-être même pas.

Pour appliquer les exemples de règles à votre cluster, exécutez la commande suivante :

kubectl apply -n NAMESPACE_NAME -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.12.0/examples/rules.yaml

Après quelques minutes, la métrique job:up:sum devient disponible. L'alerte AlwaysFiring commence également à se déclencher. Pour en savoir plus sur l'envoi d'alertes à Alertmanager, consultez la page Configuration d'Alertmanager.

Les ressources ClusterRules et GlobalRules fournissent la même interface que la ressource Rules, mais elles appliquent les règles à des champs d'application plus larges. Les objets ClusterRules sélectionnent les données à l'aide des libellés project_id et cluster, et les règles globales sélectionnent toutes les données dans le champ d'application des métriques interrogées sans restreindre les libellés.

Pour obtenir une documentation de référence sur toutes les ressources personnalisées Managed Service pour Prometheus, consultez la documentation prometheus-engine/doc/api reference.

Convertir des règles Prometheus en ressource Règles

La ressource Règles fournit une interface compatible avec les règles Prometheus afin de fournir un chemin de migration fluide pour intégrer les règles existantes dans l'évaluation des règles gérées. Vous pouvez inclure vos règles existantes dans une ressource Règles. Par exemple, voici une règle Prometheus :

groups:
- name: example
  interval: 30s
  rules:
  - record: job:up:sum
    expr: sum without(instance) (up)
  - alert: AlwaysFiring
    expr: vector(1)

La ressource Règles correspondante, avec la règle Prometheus d'origine en gras est la suivante :

apiVersion: monitoring.googleapis.com/v1
kind: Rules
metadata:
  namespace: NAMESPACE_NAME
  name: example-rules
spec:
  groups:
  - name: example
    interval: 30s
    rules:
    - record: job:up:sum
      expr: sum without(instance) (up)
    - alert: AlwaysFiring
      expr: vector(1)

ClusterRules

Vous pouvez utiliser la ressource ClusterRules pour configurer les règles d'enregistrement et d'alerte pouvant évaluer toutes les séries temporelles envoyées à Managed Service pour Prometheus à partir de tous les espaces de noms d'un cluster particulier. La spécification est identique à celle de Rules. L'exemple de règle Prometheus précédent devient la ressource ClusterRules suivante :

apiVersion: monitoring.googleapis.com/v1
kind: ClusterRules
metadata:
  name: example-clusterrules
spec:
  groups:
  - name: example
    interval: 30s
    rules:
    - record: job:up:sum
      expr: sum without(instance) (up)
    - alert: AlwaysFiring
      expr: vector(1)

Nous vous recommandons de n'utiliser les ressources ClusterRules que sur les métriques horizontales, telles que celles produites par un maillage de services. Pour les métriques de déploiements individuels, utilisez les ressources Règles pour vous assurer que l'évaluation n'inclut pas de données indésirables.

GlobalRules

Vous pouvez utiliser la ressource GlobalRules pour configurer les règles d'enregistrement et d'alerte pouvant évaluer toutes les séries temporelles envoyées à Managed Service pour Prometheus dans tous les projets d'un champ d'application de métriques. La spécification est identique à celle de Rules. L'exemple de règle Prometheus précédent devient la ressource GlobalRules suivante :

apiVersion: monitoring.googleapis.com/v1
kind: GlobalRules
metadata:
  name: example-globalrules
spec:
  groups:
  - name: example
    interval: 30s
    rules:
    - record: job:up:sum
      expr: sum without(instance) (up)
    - alert: AlwaysFiring
      expr: vector(1)

Étant donné que les métriques Cloud Monitoring ne sont pas limitées à un espace de noms ou à un cluster, vous devez utiliser la ressource GlobalRules lorsque vous écrivez des règles ou des alertes pour des métriques Cloud Monitoring. L'utilisation de la ressource GlobalRules est également requise pour définir des alertes sur les métriques système Google Kubernetes Engine.

Si votre règle ne conserve pas les libellés project_id ou location, les valeurs par défaut du cluster sont utilisées.

Pour les métriques Managed Service pour Prometheus, nous vous recommandons de n'utiliser la ressource GlobalRules que pour les rares cas où une alerte peut nécessiter des données sur tous les clusters à la fois. Pour les métriques portant sur des déploiements individuels, utilisez les ressources Rules ou ClusterRules pour améliorer la fiabilité et vous assurer que l'évaluation n'inclut pas de données indésirables. Nous vous recommandons vivement de conserver les libellés cluster et namespace dans les résultats de l'évaluation de la règle, sauf si l'objectif de la règle est d'agréger ces libellés, sinon les performances des requêtes peuvent diminuer et vous risquez de rencontrer des problèmes de limites de cardinalité. Il est fortement déconseillé de supprimer les deux libellés.

Évaluation des règles multiprojets et globales

Lorsqu'il est déployé sur Google Kubernetes Engine, l'évaluateur de règle utilise le projet Google Cloud associé au cluster, qu'il détecte automatiquement. Pour évaluer les règles qui s'appliquent à plusieurs projets, vous devez configurer l'évaluateur de règle qui exécute la ressource GlobalRules pour qu'il utilise un projet avec un champ d'application de métriques multiprojets. Pour cela, vous avez le choix entre deux méthodes :

Placez votre ressource GlobalRules dans un projet doté d'un champ d'application de métriques multiprojets.
Définissez le champ queryProjectID dans OperatorConfig pour utiliser un projet avec un champ d'application de métriques multiprojets.

Vous devez également mettre à jour les autorisations du compte de service utilisé par l'évaluateur de règle (il s'agit généralement du compte de service par défaut sur le nœud) pour que le compte de service puisse lire le projet de champ d'application et écrire dans tous les projets surveillés du champ d'application des métriques.

Si le champ d'application des métriques contient tous vos projets, vos règles sont évaluées globalement. Pour plus d'informations, consultez la section Champs d'application des métriques.

Créer des alertes à l'aide des métriques Cloud Monitoring

Vous pouvez utiliser la ressource GlobalRules pour définir des alertes sur les métriques système Google Cloud à l'aide de PromQL. Pour obtenir des instructions sur la création d'une requête valide, consultez la page PromQL pour les métriques Cloud Monitoring.

Configurer des règles et des alertes à l'aide de Terraform

Vous pouvez automatiser la création et la gestion de ressources Rules, ClusterRules et GlobalRules à l'aide du type de ressource Terraform kubernetes_manifest ou du type de ressource Terraform kubectl_manifest, qui vous permettent de spécifier des ressources personnalisées arbitraires.

Pour obtenir des informations générales sur l'utilisation de Google Cloud avec Terraform, consultez la page Terraform avec Google Cloud.

Fournir des identifiants de manière explicite

Lors de l'exécution sur GKE, l'évaluateur de règle récupère automatiquement les identifiants de l'environnement en fonction du compte de service du nœud. Dans les clusters Kubernetes non GKE, les identifiants doivent être explicitement fournis via la ressource OperatorConfig dans l'espace de noms gmp-public.

Définissez le contexte de votre projet cible :
```
gcloud config set project PROJECT_ID
```

Créez un compte de service :

gcloud iam service-accounts create gmp-test-sa

Accordez les autorisations requises au compte de service :

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

Créez et téléchargez une clé pour le compte de service :

gcloud iam service-accounts keys create gmp-test-sa-key.json \
  --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Ajoutez le fichier de clé en tant que secret à votre cluster non-GKE :

kubectl -n gmp-public create secret generic gmp-test-sa \
  --from-file=key.json=gmp-test-sa-key.json

Ouvrez la ressource OperatorConfig pour la modifier :
```
kubectl -n gmp-public edit operatorconfig config
```
1. Ajoutez le texte affiché en gras à la ressource :
```
apiVersion: monitoring.googleapis.com/v1
kind: OperatorConfig
metadata:
  namespace: gmp-public
  name: config
rules:
  credentials:
    name: gmp-test-sa
    key: key.json
```
  Veillez également à ajouter ces identifiants à la section collection pour que la collection gérée fonctionne.
2. Enregistrez le fichier et fermez l'éditeur. Une fois la modification appliquée, les pods sont recréés et commencent à s'authentifier auprès du backend de métrique avec le compte de service donné.
Évaluation des règles de scaling

L'évaluateur de règle s'exécute en tant que déploiement d'instance dupliquée unique, avec des demandes et des limites de ressources fixes. Vous remarquerez peut-être que la charge de travail subit des perturbations, telles qu'un arrêt OOMKilled lors de l'évaluation d'un grand nombre de règles. Pour éviter ce problème, vous pouvez déployer un VerticalPodAutoscaler afin d'effectuer un scaling vertical du déploiement. Tout d'abord, assurez-vous que l'autoscaling de pods verticaux est activé sur votre cluster Kubernetes. Appliquez ensuite une ressource VerticalPodAutoscaler telle que :
```
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: rule-evaluator
  namespace: gmp-system
spec:
  resourcePolicy:
    containerPolicies:
    - containerName: evaluator
      controlledResources:
        - memory
      maxAllowed:
        memory: 4Gi
      minAllowed:
        memory: 16Mi
      mode: Auto
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: rule-evaluator
  updatePolicy:
    updateMode: Auto
```
Vous pouvez vérifier que l'autoscaler fonctionne en vérifiant son état :
```
kubectl get vpa --namespace gmp-system rule-evaluator
```
Si l'autoscaler fonctionne, il indique qu'il a calculé les recommandations de ressources pour la charge de travail dans la colonne "PROVIDED" :
```
NAME             MODE   CPU   MEM        PROVIDED   AGE
rule-evaluator   Auto   2m    11534336   True       30m
```
Configurations de compression

Si vous disposez de nombreuses ressources Rules, vous risquez de manquer d'espace ConfigMap. Pour résoudre ce problème, activez la compression gzip dans votre ressource OperatorConfig :
```
  apiVersion: monitoring.googleapis.com/v1
  kind: OperatorConfig
  metadata:
    namespace: gmp-public
    name: config
  features:
    config:
      compression: gzip
```
Configuration d'Alertmanager

Vous pouvez utiliser la ressource OperatorConfig pour configurer l'évaluateur de règle gérée afin d'envoyer des alertes à un Alertmanager Prometheus. Vous pouvez envoyer des alertes au Alertmanager géré automatiquement déployé en plus des Alertmanagers auto-déployés.

Alertmanager géré

Preview

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Le service géré pour Prometheus déploie une instance gérée d'Alertmanager, sur laquelle les évaluateurs de règles sont automatiquement configurés pour transférer les alertes. Par défaut, cette configuration est définie avec un secret Kubernetes spécifiquement nommé contenant un fichier de configuration Alertmanager.

Pour activer et configurer la création de rapports sur l'instance Alertmanager déployée, procédez comme suit :
1. Créez un fichier de configuration local contenant vos paramètres Alertmanager (consultez les exemples de modèles de configuration) :
```
touch alertmanager.yaml
```
2. Mettez à jour le fichier avec les paramètres Alertmanager souhaités et créez un secret nommé alertmanager dans l'espace de noms gmp-public :
```
kubectl create secret generic alertmanager \
  -n gmp-public \
  --from-file=alertmanager.yaml
```
Après quelques instants, le service géré pour Prometheus récupère le nouveau secret de configuration et active le gestionnaire d'alertes géré avec vos paramètres.

Personnaliser le nom du secret de configuration

L'Alertmanager géré accepte également les noms de secrets personnalisés pour le chargement de la configuration. Cette fonctionnalité est utile lorsque vous disposez de plusieurs secrets de configuration et que vous souhaitez que votre instance Alertmanager bascule entre les configurations correspondantes. Par exemple, vous pouvez modifier les canaux de notification d'alerte en fonction des rotations d'astreinte en rotation, ou également effectuer une pagination dans une configuration d'alerte expérimentale pour tester une nouvelle route d'alerte.

Pour spécifier un nom secret autre que celui par défaut à l'aide de la ressource OperatorConfig, procédez comme suit :
1. Créez un secret à partir de votre fichier de configuration Alertmanager local :
```
kubectl create secret generic SECRET_NAME \
  -n gmp-public \
  --from-file=FILE_NAME
```
2. Ouvrez la ressource OperatorConfig pour la modifier :
```
kubectl -n gmp-public edit operatorconfig config
```
3. Pour activer les rapports Alertmanager gérés, modifiez la ressource en modifiant la section managedAlertmanager comme indiqué dans le texte en gras suivant :
```
apiVersion: monitoring.googleapis.com/v1
kind: OperatorConfig
metadata:
  namespace: gmp-public
  name: config
managedAlertmanager:
  configSecret:
    name: SECRET_NAME
    key: FILE_NAME
```
Si vous devez apporter des modifications à la configuration Alertmanager, vous pouvez ensuite la modifier en mettant à jour le secret que vous avez créé précédemment.

Personnaliser l'URL externe

Vous pouvez configurer l'URL externe d'Altermanager géré afin que les notifications d'alerte puissent fournir un lien de rappel à l'interface utilisateur des alertes. Cela équivaut à utiliser l'option --web.external-url de Prometheus Alertmanager en amont.
```
apiVersion: monitoring.googleapis.com/v1
kind: OperatorConfig
metadata:
  namespace: gmp-public
  name: config
managedAlertmanager:
  externalURL: EXTERNAL_URL
```
Alertmanager auto-déployé

Pour configurer l'évaluateur de règle pour un Alertmanager auto-déployé, procédez comme suit :
1. Ouvrez la ressource OperatorConfig pour la modifier :
```
kubectl -n gmp-public edit operatorconfig config
```
2. Configurez la ressource pour envoyer des alertes à votre service Alertmanager :
```
apiVersion: monitoring.googleapis.com/v1
kind: OperatorConfig
metadata:
  namespace: gmp-public
  name: config
rules:
  alerting:
    alertmanagers:
    - name: SERVICE_NAME
      namespace: SERVICE_NAMESPACE
      port: PORT_NAME
```
Si votre Alertmanager se trouve dans un cluster différent de celui de votre évaluateur de règle, vous devrez peut-être configurer une ressource Endpoints. Par exemple, si la ressource OperatorConfig indique que les points de terminaison Alertmanager peuvent se trouver dans l'objet Endpoints ns=alertmanager/name=alertmanager, vous pouvez créer manuellement ou automatiquement cet objet et le renseigner avec des adresses IP accessibles depuis l'autre cluster. La section de configuration AlertmanagerEndpoints fournit des options permettant de configurer des autorisations si nécessaire.

Évaluation des règles gérées et alertes