Surveiller Anthos Config Management

Anthos Config Management utilise Prometheus pour recueillir et afficher des métriques relatives à ses processus.

Vous pouvez également configurer Cloud Monitoring pour extraire des métriques personnalisées de Prometheus. Ces métriques peuvent ensuite être affichées dans Prometheus et Monitoring. Pour en savoir plus, consultez la page Utiliser Prometheus.

Scraper les métriques

Toutes les métriques Prometheus peuvent être scrapées (c'est-à-dire récupérées) sur le port 8675. Pour pouvoir scraper des métriques, vous devez configurer votre cluster pour Prometheus de l'une des deux manières suivantes :

  • Reportez-vous à la documentation Prometheus pour configurer votre cluster en vue du scrape ou

  • Utilisez l'opérateur Prometheus fourni par CoreOS avec les fichiers manifestes ci-dessous de façon à scraper l'ensemble des métriques Anthos Config Management toutes les 10 secondes.

    1. Créez un répertoire temporaire pour y placer les fichiers manifestes.

      mkdir acm-monitor
      cd acm-monitor
      
    2. Téléchargez le manifeste de l'opérateur Prometheus à partir du dépôt CoreOS, à l'aide de la commande curl :

      curl -o bundle.yaml https://raw.githubusercontent.com/coreos/prometheus-operator/master/bundle.yaml
      

      Ce fichier manifeste est configuré pour utiliser l'espace de noms default, ce qui n'est pas recommandé. L'étape suivante modifie la configuration pour utiliser un espace de noms appelé monitoring. Pour utiliser un autre espace de noms, remplacez-le par monitoring dans les étapes restantes.

    3. Créez un fichier pour mettre à jour l'objet Namespace de la ressource ClusterRoleBinding dans le package ci-dessus.

      # patch-crb.yaml
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: prometheus-operator
      subjects:
      - kind: ServiceAccount
        name: prometheus-operator
        namespace: monitoring # we are patching from default namespace
      
    4. Créez un fichier kustomization.yaml qui applique le correctif et modifie l'objet Namespace pour les autres ressources du fichier manifeste.

      # kustomization.yaml
      resources:
      - bundle.yaml
      
      namespace: monitoring
      
      patchesStrategicMerge:
      - patch-crb.yaml
      
    5. Créez l'espace de noms monitoring. Vous pouvez utiliser un nom différent pour l'espace de noms, mais vous devrez modifier la valeur de namespace dans les fichiers manifestes YAML des étapes précédentes.

      kubectl create namespace monitoring
      
    6. Appliquez le fichier manifeste kustomized à l'aide des commandes suivantes :

      kubectl apply -k .
      
      until kubectl get customresourcedefinitions servicemonitors.monitoring.coreos.com ; \
      do date; sleep 1; echo ""; done

      La deuxième commande bloque jusqu'à ce que les CRD soient disponibles sur le cluster.

    7. Créez le fichier manifeste pour les ressources nécessaires à la configuration d'un serveur Prometheus qui récupère les métriques d'Anthos Config Management.

      # acm.yaml
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: prometheus-acm
        namespace: monitoring
      ---
      apiVersion: rbac.authorization.k8s.io/v1beta1
      kind: ClusterRole
      metadata:
        name: prometheus-acm
      rules:
      - apiGroups: [""]
        resources:
        - nodes
        - services
        - endpoints
        - pods
        verbs: ["get", "list", "watch"]
      - apiGroups: [""]
        resources:
        - configmaps
        verbs: ["get"]
      - nonResourceURLs: ["/metrics"]
        verbs: ["get"]
      ---
      apiVersion: rbac.authorization.k8s.io/v1beta1
      kind: ClusterRoleBinding
      metadata:
        name: prometheus-acm
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: prometheus-acm
      subjects:
      - kind: ServiceAccount
        name: prometheus-acm
        namespace: monitoring
      ---
      apiVersion: monitoring.coreos.com/v1
      kind: Prometheus
      metadata:
        name: acm
        namespace: monitoring
        labels:
          prometheus: acm
      spec:
        replicas: 2
        serviceAccountName: prometheus-acm
        serviceMonitorSelector:
          matchLabels:
            prometheus: config-management
        podMonitorSelector:
          matchLabels:
            prometheus: config-management
        alerting:
          alertmanagers:
          - namespace: default
            name: alertmanager
            port: web
        resources:
          requests:
            memory: 400Mi
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: prometheus-acm
        namespace: monitoring
        labels:
          prometheus: acm
      spec:
        type: NodePort
        ports:
        - name: web
          nodePort: 31900
          port: 9190
          protocol: TCP
          targetPort: web
        selector:
          app: prometheus
          prometheus: acm
      ---
      apiVersion: monitoring.coreos.com/v1
      kind: ServiceMonitor
      metadata:
        name: acm-service
        namespace: monitoring
        labels:
          prometheus: config-management
      spec:
        selector:
          matchLabels:
            monitored: "true"
        namespaceSelector:
          matchNames:
          - config-management-system
        endpoints:
        - port: metrics
          interval: 10s
      ---
      apiVersion: monitoring.coreos.com/v1
      kind: ServiceMonitor
      metadata:
        name: cnrm
        namespace: monitoring
        labels:
          prometheus: config-management
      spec:
        endpoints:
        - interval: 10s
          port: metrics
        namespaceSelector:
          matchNames:
          - cnrm-system
        selector:
          matchLabels:
            cnrm.cloud.google.com/monitored: "true"
            cnrm.cloud.google.com/system: "true"
      ---
      apiVersion: monitoring.coreos.com/v1
      kind: PodMonitor
      metadata:
        name: acm-pod
        namespace: monitoring
        labels:
          prometheus: config-management
      spec:
        selector:
          matchLabels:
            monitored: "true"
        namespaceSelector:
          matchNames:
          - gatekeeper-system
        podMetricsEndpoints:
        - port: metrics
          interval: 10s
      
    8. Appliquez le fichier manifeste à l'aide des commandes suivantes :

      kubectl apply -f acm.yaml
      
      until kubectl rollout status statefulset/prometheus-acm -n monitoring; \
      do sleep 1; done
      

      La deuxième commande bloque jusqu'à ce que les pods soient en cours d'exécution.

    9. Vous pouvez vérifier l'installation en transférant le port Web du serveur Prometheus sur votre ordinateur local.

      kubectl -n monitoring port-forward svc/prometheus-acm 9190
      

      Vous pouvez désormais accéder à l'interface utilisateur Web de Prometheus à l'adresse http://localhost:9190.

    10. Supprimez le répertoire temporaire.

      cd ..
      rm -rf acm-monitor
      

Métriques disponibles

Anthos Config Management recueille les métriques ci-dessous et les met à la disposition de Prometheus. La colonne Libellés répertorie toutes les libellés applicables à chaque métrique. Les métriques sans libellés représentent une seule mesure dans le temps tandis que les métriques avec libellés représentent plusieurs mesures, une pour chaque combinaison de valeurs de libellé.

Si cette table n'est plus synchronisée, vous pouvez filtrer les métriques par préfixe dans l'interface utilisateur de Prometheus. Toutes les métriques commencent par le préfixe gkeconfig_.

Nom Type Libellés Description
gkeconfig_importer_cycle_duration_seconds_bucket Histogramme état Nombre de cycles que l'outil d'importation a tenté d'exécuter afin d'importer des configurations dans le cluster (répartis en buckets par durée de chaque cycle)
gkeconfig_importer_cycle_duration_seconds_count Histogramme état Nombre de cycles que l'outil d'importation a tenté d'exécuter afin d'importer des configurations dans le cluster (en ignorant la durée)
gkeconfig_importer_cycle_duration_seconds_sum Histogramme état Somme des durées de tous les cycles que l'outil d'importation a tenté d'exécuter afin d'importer des configurations dans le cluster
gkeconfig_importer_namespace_configs Jauge Nombre de configurations d'espace de noms dans l'état actuel
gkeconfig_monitor_errors Jauge composant Nombre d'erreurs dans le dépôt de configuration regroupées selon le composant où elles se sont produites
gkeconfig_monitor_configs Jauge état Nombre de configurations (cluster et espace de noms) regroupées par leur état de synchronisation
gkeconfig_monitor_last_import_timestamp Jauge Horodatage de la dernière importation
gkeconfig_monitor_last_sync_timestamp Jauge Horodatage de la dernière synchronisation
gkeconfig_monitor_sync_latency_seconds_bucket Histogramme Nombre de mesures d'importation pour synchronisation relevées (réparties en buckets en fonction de la latence entre les deux)
gkeconfig_monitor_sync_latency_seconds_count Histogramme Nombre de mesures d'importation pour synchronisation relevées (en ignorant la latence entre les deux)
gkeconfig_monitor_sync_latency_seconds_sum Histogramme Somme des latences de toutes les mesures d'importation pour synchronisation relevées
gkeconfig_syncer_api_duration_seconds_bucket Histogramme opération, type, état Nombre d'appels effectués par le synchroniseur au serveur d'API (répartis en buckets par durée de chaque appel)
gkeconfig_syncer_api_duration_seconds_count Histogramme opération, type, état Nombre d'appels effectués par l'outil d'importation au serveur d'API (en ignorant la durée)
gkeconfig_syncer_api_duration_seconds_sum Histogramme opération, type, état Somme des durées de tous les appels effectués par le synchroniseur au serveur d'API
gkeconfig_syncer_controller_restarts_total Nombre source Nombre total de redémarrages pour les contrôleurs de configuration d'espace de noms et de cluster
gkeconfig_syncer_operations_total Nombre opération, type, état Nombre total d'opérations effectuées pour synchroniser les ressources avec les configurations
gkeconfig_syncer_reconcile_duration_seconds_bucket Histogramme type, état Nombre d'événements de rapprochement traités par le synchroniseur (répartis en buckets par durée)
gkeconfig_syncer_reconcile_duration_seconds_count Histogramme type, état Nombre d'événements de rapprochement traités par le synchroniseur (en ignorant la durée)
gkeconfig_syncer_reconcile_duration_seconds_sum Histogramme type, état Somme des durées de tous les événements de rapprochement traités par le synchroniseur
gkeconfig_syncer_reconcile_event_timestamps Jauge type Horodatages lorsque les événements de rapprochement du synchroniseur se sont produits
Si vous utilisez Config Connector, la liste des métriques est visible dans la section Surveiller Config Connector avec Prometheus.

Si Policy Controller est activé sur votre cluster, les métriques additionnelles suivantes seront disponibles (toutes précédées de gatekeeper_) :

Nom Type Libellés Description
gatekeeper_audit_duration_seconds Histogramme Distribution de la durée du cycle d'audit
gatekeeper_audit_last_run_time Jauge Horodatage de l'époque depuis la dernière exécution d'audit, exprimé en secondes en virgule flottante
gatekeeper_constraint_template_ingestion_count Nombre état Nombre total d'actions d'ingestion de modèle de contrainte
gatekeeper_constraint_template_ingestion_duration_seconds Histogramme état Distribution de la durée d'ingestion de modèle de contrainte
gatekeeper_constraint_templates Jauge état Nombre actuel de modèles de contraintes
gatekeeper_constraints Jauge enforcement_action, état Nombre actuel de contraintes
gatekeeper_request_count Nombre admission_status Décompte de requêtes d'admission du serveur d'API
gatekeeper_request_duration_seconds Histogramme admission_status Distribution de la durée des requêtes d'admission
gatekeeper_violations Jauge enforcement_action Nombre de violations des règles d'audit détectées au cours du dernier cycle d'audit
gatekeeper_watch_manager_intended_watch_gvk Jauge Nombre de GroupVersionKinds uniques que Policy Controller est censé surveiller. Il s'agit d'une combinaison de ressources et de contraintes synchronisées. Non mis en œuvre actuellement
gatekeeper_watch_manager_watched_gvk Jauge Nombre de GroupVersionKinds uniques que Policy Controller surveille réellement. Il est censé converger pour correspondre à gatekeeper_watch_manager_intended_watch_gvk. Non mis en œuvre actuellement
gatekeeper_sync Jauge genre, état Nombre de ressources qui ont été répliquées dans le cache de l'OPA
gatekeeper_sync_duration_seconds Histogramme Distribution de la durée de synchronisation des objets
gatekeeper_sync_last_run_time Jauge Date et heure de la dernière synchronisation d'une ressource

Exemples de procédures de débogage

Les exemples suivants illustrent certains modèles d'utilisation des métriques Prometheus, des champs d'état d'objet et des annotations d'objets pour détecter et diagnostiquer les problèmes liés à Anthos Config Management. Ces exemples montrent comment commencer avec une surveillance de haut niveau qui détecte un problème, puis comment affiner progressivement votre recherche pour en identifier et diagnostiquer la cause.

Interroger des configurations par état

Le processus monitor fournit des métriques de haut niveau qui donnent des indications précieuses sur une vue d'ensemble du fonctionnement d'Anthos Config Management sur le cluster. Vous pouvez voir si des erreurs se sont produites et même configurer des alertes pour ces erreurs.

gkeconfig_monitor_errors

Utiliser nomos status pour afficher les erreurs

En plus d'utiliser les métriques Prometheus pour surveiller l'état d'Anthos Config Management sur vos clusters, vous pouvez utiliser la commande nomos status qui affiche les erreurs de tous vos clusters sur la ligne de commande.

Interroger des opérations d'importation et de synchronisation par état

Anthos Config Management utilise un processus en deux étapes pour appliquer les configurations du dépôt à un cluster. La métrique gkeconfig_monitor_errors est libellée par composant, ce qui vous permet de savoir où se sont produites les erreurs.

gkeconfig_monitor_errors{component="importer"}
gkeconfig_monitor_errors{component="syncer"}

Vous pouvez également vérifier les métriques des processus d'importation et de synchronisation eux-mêmes.

gkeconfig_importer_cycle_duration_seconds_count{status="error"}
gkeconfig_syncer_reconcile_duration_seconds_count{status="error"}

Vérifier l'état de l'objet de configuration

Anthos Config Management définit deux objets Kubernetes personnalisés : ClusterConfig et NamespaceConfig. Ces objets définissent un champ d'état contenant des informations sur la dernière modification appliquée à la configuration et sur les erreurs qui se sont produites. Par exemple, si une erreur se produit dans un espace de noms appelé shipping-dev, vous pouvez vérifier l'état du NamespaceConfig correspondant.

kubectl get namespaceconfig shipping-dev -o yaml

Vérifier l'annotation token d'un objet

Vous pouvez savoir quand un objet Kubernetes géré a été mis à jour pour la dernière fois par Anthos Config Management. Chaque objet géré est annoté avec le hachage du commit Git lors de sa dernière modification, ainsi que le chemin d'accès à la configuration contenant la modification.

kubectl get clusterrolebinding namespace-readers
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    configmanagement.gke.io/source-path: cluster/namespace-reader-clusterrolebinding.yaml
    configmanagement.gke.io/token: bbb6a1e2f3db692b17201da028daff0d38797771
  name: namespace-readers
...

Pour en savoir plus, consultez la section Libellés et annotations.

Et ensuite ?