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 L'une des options ci-dessous :

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.

Créez un répertoire temporaire pour y placer les fichiers manifestes.
```
mkdir acm-monitor
cd acm-monitor
```
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.

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

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

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

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.
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.
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 tous 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 sur la page Surveiller Config Connector à l'aide de Prometheus.

Si Policy Controller est activé sur votre cluster, les métriques additionnelles suivantes seront disponibles (toutes précédées du préfixe 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'époch depuis la dernière exécution d'audit, exprimé en secondes avec 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 contraintes et ressources synchronisées. Non mis en œuvre actuellement.
`gatekeeper_watch_manager_watched_gvk`	Jauge		Nombre de GroupVersionKinds uniques que Policy Controller surveille réellement. Ceci est censé converger pour correspondre à gatekeeper_watch_manager_intended_watch_gvk. Non mis en œuvre actuellement.
`gatekeeper_sync`	Jauge	type, é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 de 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 avez peut-être besoin de 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 qu'avec 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.

Étape suivante

Lisez le guide de démarrage rapide.
Obtenez plus d'informations sur l'affichage des journaux Anthos Config Management.