Utiliser la journalisation et la surveillance

Cette page explique comment utiliser Cloud Logging, Cloud Monitoring, Prometheus et Grafana pour la journalisation et la surveillance de votre mise en œuvre Anthos clusters on VMware (GKE On-Prem). Pour obtenir un récapitulatif des options de configuration disponibles, consultez la page Présentation de la journalisation et de la surveillance.

Utiliser Cloud Logging et Cloud Monitoring

Les sections suivantes expliquent comment utiliser Cloud Logging et Cloud Monitoring avec les clusters de Clusters Anthos sur VMware (GKE On-Prem).

Ressources surveillées

Les ressources surveillées correspondent à la manière dont Google représente les ressources, telles que les clusters, les nœuds, les pods et les conteneurs. Pour en savoir plus, consultez la documentation Types de ressources surveillées de Cloud Monitoring.

Pour interroger des journaux et des métriques, vous devez au moins connaître les libellés de ressources suivants :

project_id : ID du projet correspondant à l'ID du projet logging-monitoring du cluster. Vous avez fourni cette valeur dans le champ stackdriver.projectID du fichier de configuration du cluster.
location : région Google Cloud où vous souhaitez stocker les journaux Cloud Logging et les métriques Cloud Monitoring. Il est recommandé de choisir une région à proximité de votre centre de données sur site. Vous avez fourni cette valeur lors de l'installation dans le champ stackdriver.clusterLocation du fichier de configuration du cluster.
cluster_name : nom du cluster défini lors de la création du cluster.

Vous pouvez récupérer la valeur cluster_name du cluster d'administrateur ou d'utilisateur en inspectant la ressource personnalisée Stackdriver :
```
  kubectl -n kube-system get stackdrivers stackdriver -o yaml | grep 'clusterName:'
```

Accéder aux données des journaux

Vous pouvez accéder aux journaux à l'aide de l'explorateur de journaux de la console Google Cloud. Par exemple, pour accéder aux journaux d'un conteneur, procédez comme suit :

Dans la console Google Cloud, ouvrez l'explorateur de journaux pour votre projet.
Pour trouver les journaux d'un conteneur :
1. Cliquez sur la boîte déroulante du catalogue de journaux dans l'angle supérieur gauche, puis sélectionnez Conteneur Kubernetes.
2. Sélectionnez le nom du cluster, l'espace de noms et un conteneur dans la hiérarchie.

Créer des tableaux de bord pour surveiller l'état du cluster

Par défaut, les clusters de Clusters Anthos sur VMware sont configurés pour surveiller les métriques du système et du conteneur. Après avoir créé un cluster (d'administrateur ou d'utilisateur), il est recommandé de créer les tableaux de bord suivants avec Cloud Monitoring pour permettre à votre équipe en charge des opérations Cluster Anthos sur VMware de surveiller l'état du cluster :

Tableau de bord du temps d'activité du plan de contrôle
Tableau de bord d'état du pod
Tableau de bord d'état du nœud
Tableau de bord d'état de la VM

Les tableaux de bord sont automatiquement créés lors de l'installation du cluster d'administrateur si Cloud Monitoring est activé.

Cette section explique comment créer ces tableaux de bord. Pour plus d'informations sur le processus de création de tableau de bord décrit dans les sections suivantes, consultez la page Gérer les tableaux de bord à l'aide d'API.

Prérequis

Votre compte Google doit disposer des autorisations suivantes pour créer des tableaux de bord :

monitoring.dashboards.create
monitoring.dashboards.delete
monitoring.dashboards.update

Vous obtiendrez ces autorisations si votre compte dispose de l'un des rôles suivants. Vous pouvez vérifier vos autorisations (dans la console Google Cloud) :

monitoring.dashboardEditor
monitoring.editor
Projet editor
Projet owner

En outre, pour utiliser gcloud (gcloud CLI) afin de créer des tableaux de bord, votre compte Google doit disposer de l'autorisation serviceusage.services.use.

Votre compte disposera de cette autorisation s'il possède l'un des rôles suivants :

roles/serviceusage.serviceUsageConsumer
roles/serviceusage.serviceUsageAdmin
roles/owner
roles/editor
Projet editor
Projet owner

Créer un tableau de bord du temps d'activité du plan de contrôle

Le plan de contrôle Clusters Anthos sur VMware comprend le serveur d'API, le programmeur, le gestionnaire du contrôleur et etcd. Pour surveiller l'état du plan de contrôle, créez un tableau de bord qui surveille l'état de ces composants.

Téléchargez la configuration du tableau de bord : control-plane-uptime.json
Créez un tableau de bord personnalisé avec le fichier de configuration en exécutant la commande suivante :
```
gcloud monitoring dashboards create --config-from-file=control-plane-uptime.json
```
Dans Google Cloud Console, sélectionnez Monitoring ou utilisez le bouton suivant :

Accéder à Monitoring
Sélectionnez Ressources > Tableaux de bord, puis affichez le tableau de bord intitulé État du plan de contrôle GKE On-Prem. Le temps d'activité du plan de contrôle de chaque cluster d'utilisateur est collecté à partir d'espaces de noms distincts dans le cluster d'administrateur. Le champ namespace_name correspond au nom du cluster d'utilisateur.
Vous pouvez également créer des règles d'alerte.

Cliquez ici pour afficher un exemple de tableau de bord.

Créer un tableau de bord d'état du pod

Pour créer un tableau de bord incluant la phase de chaque pod, ainsi que les temps de redémarrage et l'utilisation des ressources de chaque conteneur, procédez comme suit.

Téléchargez la configuration du tableau de bord : pod-status.json
Créez un tableau de bord personnalisé avec le fichier de configuration en exécutant la commande suivante :
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
Dans Google Cloud Console, sélectionnez Monitoring ou utilisez le bouton suivant :

Accéder à Monitoring
Sélectionnez Ressources > Tableaux de bord, puis affichez le tableau de bord intitulé État du pod GKE On-Prem.
Vous pouvez également créer des règles d'alerte.

Cliquez ici pour afficher un exemple de tableau de bord.

Créer un tableau de bord d'état du nœud

Pour créer un tableau de bord d'état du nœud afin de surveiller l'état du nœud, le processeur, la mémoire et le disque, procédez comme suit :

Téléchargez la configuration du tableau de bord : node-status.json
Créez un tableau de bord personnalisé avec le fichier de configuration en exécutant la commande suivante :
```
gcloud monitoring dashboards create --config-from-file=node-status.json
```
Dans Google Cloud Console, sélectionnez Monitoring ou utilisez le bouton suivant :

Accéder à Monitoring
Sélectionnez Ressources > Tableaux de bord, puis affichez le tableau de bord intitulé État du nœud GKE On-Prem.
Vous pouvez également créer des règles d'alerte.

Cliquez ici pour afficher un exemple de tableau de bord.

Créer un tableau de bord d'état de la VM

Un tableau de bord indiquant l'état d'une VM surveille les signaux de conflits au niveau du processeur, de la mémoire et du disque pour les VM du cluster d'administrateur et des clusters d'utilisateur.

Pour créer un tableau de bord indiquant l'état d'une VM, procédez comme suit :

Assurez-vous que stackdriver.disableVsphereResourceMetrics est défini sur "false". Consultez la page Fichier de configuration du cluster d'utilisateur.
Téléchargez la configuration du tableau de bord : vm-health-status.json
Créez un tableau de bord personnalisé avec le fichier de configuration en exécutant la commande suivante :
```
gcloud monitoring dashboards create --config-from-file=vm-health-status.json
```
Dans Google Cloud Console, sélectionnez Monitoring ou utilisez le bouton suivant :

Accéder à Monitoring
Sélectionnez Ressources > Tableaux de bord, puis affichez le tableau de bord intitulé État de la VM GKE On-Prem.
Vous pouvez également créer des règles d'alerte.

Cliquez ici pour afficher un exemple de tableau de bord.

Configurer les ressources des composants Stackdriver

Lorsque vous créez un cluster, Clusters Anthos sur VMware crée automatiquement une ressource personnalisée Stackdriver. Vous pouvez modifier la spécification de la ressource personnalisée pour remplacer les valeurs par défaut des demandes et limites de processeurs et de mémoire d'un composant Stackdriver, et modifier séparément la taille de l'espace de stockage et la classe de stockage par défaut.

Remplacer les valeurs par défaut des demandes et limites de processeur et de mémoire

Pour remplacer ces valeurs par défaut, procédez comme suit :

Ouvrez votre ressource personnalisée Stackdriver dans un éditeur de ligne de commande :
```
kubectl --kubeconfig=KUBECONFIG -n kube-system edit stackdriver stackdriver
```
où KUBECONFIG représente le chemin d'accès au fichier kubeconfig du cluster. Il peut s'agir d'un cluster d'administrateur ou d'un cluster d'utilisateur.

Dans la ressource personnalisée Stackdriver, ajoutez le champ resourceAttrOverride sous la section spec :

resourceAttrOverride:
      POD_NAME_WITHOUT_RANDOM_SUFFIX/CONTAINER_NAME:
        LIMITS_OR_REQUESTS:
          RESOURCE: RESOURCE_QUANTITY

Notez que la section resourceAttrOverride remplace toutes les limites et demandes par défaut du composant spécifié. Voici un exemple de fichier :

apiVersion: addons.sigs.k8s.io/v1alpha1
kind: Stackdriver
metadata:
  name: stackdriver
  namespace: kube-system
spec:
  projectID: my-project
  clusterName: my-cluster
  clusterLocation: us-west-1a
  resourceAttrOverride:
    stackdriver-prometheus-k8s/prometheus-server:
      limits:
        cpu: 500m
        memory: 3000Mi
      requests:
        cpu: 300m
        memory: 2500Mi

Enregistrez les modifications et quittez l'éditeur de ligne de commande.

Vérifiez l'état des pods :

kubectl --kubeconfig=KUBECONFIG -n kube-system get pods | grep stackdriver

Par exemple, un pod opérationnel se présente comme suit :

stackdriver-prometheus-k8s-0                                2/2     Running   0          5d19h

Vérifiez la spécification du pod du composant pour vous assurer que les ressources sont définies correctement.

kubectl --kubeconfig=KUBECONFIG -n kube-system describe pod POD_NAME

où POD_NAME est le nom du pod que vous venez de modifier. Par exemple, stackdriver-prometheus-k8s-0.

La réponse se présente comme suit :

  Name:         stackdriver-prometheus-k8s-0
  Namespace:    kube-system
  ...
  Containers:
    prometheus-server:
      Limits:
        cpu: 500m
        memory: 3000Mi
      Requests:
        cpu: 300m
        memory: 2500Mi
      ...

Remplacer les valeurs par défaut de la taille de l'espace de stockage

Pour remplacer ces valeurs par défaut, procédez comme suit :

Ouvrez votre ressource personnalisée Stackdriver dans un éditeur de ligne de commande :
```
kubectl --kubeconfig=KUBECONFIG -n kube-system edit stackdriver stackdriver
```

Ajoutez le champ storageSizeOverride sous la section spec. Vous pouvez utiliser le composant stackdriver-prometheus-k8s ou stackdriver-prometheus-app. Cette section est au format suivant :

storageSizeOverride:
STATEFULSET_NAME: SIZE

Cet exemple utilise l'ensemble avec état stackdriver-prometheus-k8s et la taille 120Gi.

apiVersion: addons.sigs.k8s.io/v1alpha1
kind: Stackdriver
metadata:
  name: stackdriver
  namespace: kube-system
spec:
  projectID: my-project
  clusterName: my-cluster
  clusterLocation: us-west-1a
  storageSizeOverride:
    stackdriver-prometheus-k8s: 120Gi

Enregistrez les modifications, puis quittez l'éditeur de ligne de commande.

Vérifiez l'état des pods :

kubectl --kubeconfig=KUBECONFIG -n kube-system get pods | grep stackdriver

Par exemple, un pod opérationnel se présente comme suit :

stackdriver-prometheus-k8s-0                                2/2     Running   0          5d19h

Vérifiez la spécification du pod du composant pour vous assurer que la taille de l'espace de stockage a bien été remplacée.

kubectl --kubeconfig=KUBECONFIG -n kube-system describe statefulset STATEFULSET_NAME

La réponse se présente comme suit :

Volume Claims:
 Name:          my-statefulset-persistent-volume-claim
 StorageClass:  my-storage-class
 Labels:
 Annotations:
 Capacity:      120Gi
 Access Modes:  [ReadWriteOnce]

Remplacer les valeurs par défaut des classes de stockage

Conditions préalables

Vous devez d'abord créer une ressource StorageClass à utiliser.

Pour remplacer la classe de stockage par défaut des volumes persistants revendiqués par les composants Logging et Monitoring, procédez comme suit :

Ouvrez votre ressource personnalisée Stackdriver dans un éditeur de ligne de commande :
```
kubectl --kubeconfig=KUBECONFIG -n kube-system edit stackdriver stackdriver
```
où KUBECONFIG représente le chemin d'accès au fichier kubeconfig du cluster. Il peut s'agir d'un cluster d'administrateur ou d'un cluster d'utilisateur.

Ajoutez le champ storageClassName sous la section spec :

storageClassName: STORAGECLASS_NAME

Notez que le champ storageClassName remplace la classe de stockage par défaut et s'applique à tous les composants Logging et Monitoring avec des volumes persistants revendiqués. Voici un exemple de fichier :

apiVersion: addons.sigs.k8s.io/v1alpha1
kind: Stackdriver
metadata:
name: stackdriver
namespace: kube-system
spec:
projectID: my-project
clusterName: my-cluster
clusterLocation: us-west-1a
proxyConfigSecretName: my-secret-name
enableVPC: 
optimizedMetrics: true
storageClassName: my-storage-class

Enregistrez les modifications.

Vérifiez l'état des pods :

kubectl --kubeconfig=KUBECONFIG -n kube-system get pods | grep stackdriver

Par exemple, un pod opérationnel se présente comme suit :

stackdriver-prometheus-k8s-0                                1/1     Running   0          5d19h

Vérifiez la spécification de pod d'un composant pour vous assurer que la classe de stockage est correctement définie.

kubectl --kubeconfig=KUBECONFIG -n kube-system describe statefulset STATEFULSET_NAME

Par exemple, en utilisant l'ensemble avec état stackdriver-prometheus-k8s, la réponse se présente comme suit :

Volume Claims:
 Name:          stackdriver-prometheus-data
 StorageClass:  my-storage-class
 Labels:
 Annotations:
 Capacity:      120Gi
 Access Modes:  [ReadWriteOnce]

Accéder aux données des métriques

L'explorateur de métriques vous permet de choisir parmi plus de 1 500 métriques. Pour y accéder, procédez comme suit :

Dans Google Cloud Console, sélectionnez Monitoring ou utilisez le bouton suivant :

Accéder à Monitoring
Sélectionnez Ressources > Explorateur de métriques.

Accéder aux métadonnées Monitoring

Les métadonnées sont utilisées indirectement via les métriques. Dans l'explorateur de métriques Monitoring, des options vous permettent de filtrer les métriques par metadata.systemLabels et metadata.userLabels. Les libellés système correspondent à des libellés tels que le nom du nœud et le nom du service pour les pods. Les libellés utilisateur sont des libellés attribués aux pods dans les fichiers YAML Kubernetes dans la section "Métadonnées" de la spécification du pod.

Limites de quotas Cloud Monitoring par défaut

La surveillance Clusters Anthos sur VMware est limitée par défaut à 6 000 appels d'API par minute pour chaque projet. Si vous dépassez cette limite, il est possible que vos métriques ne s'affichent pas. Si vous avez besoin d'une limite de surveillance plus élevée, faites-en la demande via Google Cloud Console.

Problème connu : condition d'erreur Cloud Monitoring

(ID du problème 159761921)

Dans certaines conditions, le pod Cloud Monitoring par défaut, déployé par défaut dans chaque nouveau cluster, peut ne plus répondre. Lors de la mise à niveau des clusters, par exemple, les données de stockage peuvent être corrompues lorsque des pods de statefulset/prometheus-stackdriver-k8s sont redémarrés.

Plus précisément, le pod de surveillance stackdriver-prometheus-k8s-0 peut tourner en boucle lorsque des données corrompues empêchent l'écriture de prometheus-stackdriver-sidecar sur l'espace de stockage du cluster PersistentVolume.

Vous pouvez diagnostiquer et récupérer manuellement l'erreur en suivant les étapes ci-dessous.

Diagnostiquer l'échec de Cloud Monitoring

Lorsque le pod de surveillance a échoué, les journaux indiquent les éléments suivants :

{"log":"level=warn ts=2020-04-08T22:15:44.557Z caller=queue_manager.go:534 component=queue_manager msg=\"Unrecoverable error sending samples to remote storage\" err=\"rpc error: code = InvalidArgument desc = One or more TimeSeries could not be written: One or more points were written more frequently than the maximum sampling period configured for the metric.: timeSeries[0-114]; Unknown metric: kubernetes.io/anthos/scheduler_pending_pods: timeSeries[196-198]\"\n","stream":"stderr","time":"2020-04-08T22:15:44.558246866Z"}

{"log":"level=info ts=2020-04-08T22:15:44.656Z caller=queue_manager.go:229 component=queue_manager msg=\"Remote storage stopped.\"\n","stream":"stderr","time":"2020-04-08T22:15:44.656798666Z"}

{"log":"level=error ts=2020-04-08T22:15:44.663Z caller=main.go:603 err=\"corruption after 29032448 bytes: unexpected non-zero byte in padded page\"\n","stream":"stderr","time":"2020-04-08T22:15:44.663707748Z"}

{"log":"level=info ts=2020-04-08T22:15:44.663Z caller=main.go:605 msg=\"See you next time!\"\n","stream":"stderr","time":"2020-04-08T22:15:44.664000941Z"}

Procéder à la récupération après l'erreur Cloud Monitoring

Pour récupérer Cloud Monitoring manuellement :

Arrêtez la surveillance du cluster. Réduisez la capacité de l'opérateur stackdriver pour empêcher la réconciliation de la surveillance :
```
kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system scale deployment stackdriver-operator --replicas 0
```

Supprimez les charges de travail du pipeline de surveillance:

kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system delete statefulset stackdriver-prometheus-k8s

Supprimez les PersistentVolumeClaims (PVC) du pipeline de surveillance :

kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system delete pvc -l app=stackdriver-prometheus-k8s

Redémarrez la surveillance du cluster. Augmenter la capacité de l'opérateur Stackdriver pour réinstaller un nouveau pipeline de surveillance et reprendre la réconciliation :
```
kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system scale deployment stackdriver-operator --replicas=1
```

Prometheus et Grafana

Les sections suivantes expliquent comment utiliser Prometheus et Grafana avec des clusters de Clusters Anthos sur VMware.

Activer Prometheus et Grafana

À partir de la version 1.2 de Cluster Anthos sur VMware, vous pouvez choisir d'activer ou de désactiver Prometheus et Grafana. Dans les nouveaux clusters d'utilisateur, Prometheus et Grafana sont désactivés par défaut.

Votre cluster d'utilisateur dispose d'un objet Monitoring nommé monitoring-sample. Ouvrez l'objet à modifier :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] edit \
   monitoring monitoring-sample --namespace kube-system
```
où [USER_CLUSTER_KUBECONFIG] est le fichier kubeconfig pour votre cluster d'utilisateur.

Pour activer Prometheus et Grafana, définissez enablePrometheus sur true. Pour les désactiver, définissez enablePrometheus sur false :

apiVersion: addons.k8s.io/v1alpha1
kind: Monitoring
metadata:
 labels:
   k8s-app: monitoring-operator
 name: monitoring-sample
 namespace: kube-system
spec:
 channel: stable
 ...
 enablePrometheus: true

Fermez la session de modification pour enregistrer les modifications.

Problème connu

Lors de la mise à niveau des clusters d'utilisateur, Prometheus et Grafana sont automatiquement désactivés. Cependant, les données de configuration et de métriques sont conservées.

Pour contourner ce problème, ouvrez l'objet monitoring-sample après la mise à niveau pour y apporter des modifications, puis définissez enablePrometheus sur true.

Accéder aux métriques de surveillance à partir des tableaux de bord Grafana

Grafana affiche les métriques collectées à partir de vos clusters. Pour les consulter, vous devez accéder aux tableaux de bord de Grafana :

Obtenez le nom du pod Grafana qui s'exécute dans l'espace de noms kube-system d'un cluster d'utilisateur :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get pods
```
où [USER_CLUSTER_KUBECONFIG] est le fichier kubeconfig du cluster d'utilisateur.
Le pod Grafana dispose d'un serveur HTTP qui écoute sur le port TCP 3000. Transférez un port local vers le port 3000 du pod afin de pouvoir afficher les tableaux de bord de Grafana depuis un navigateur Web.

Par exemple, supposons que le nom du pod soit grafana-0. Pour transférer le port 50000 vers le port 3000 du pod, saisissez la commande suivante :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system port-forward grafana-0 50000:3000
```
Dans votre navigateur Web, accédez à la page http://localhost:50000.
Sur la page de connexion, saisissez admin comme nom d'utilisateur et comme mot de passe.
Si la connexion aboutit, un message vous invite à modifier le mot de passe. Une fois que vous avez modifié le mot de passe par défaut, le tableau de bord de la page d'accueil Grafana du cluster d'utilisateur apparaît.
Pour accéder à d'autres tableaux de bord, cliquez sur le menu déroulant Home (Accueil) dans l'angle supérieur gauche de la page.

Pour obtenir un exemple d'utilisation de Grafana, consultez Créer un tableau de bord Grafana.

Accéder aux alertes

Prometheus Alertmanager collecte les alertes du serveur Prometheus. Vous pouvez afficher ces alertes dans un tableau de bord Grafana. Pour ce faire, vous devez accéder au tableau de bord :

Le conteneur du pod alertmanager-0 écoute sur le port TCP 9093. Transférez un port local vers le port 9093 du pod :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward \
   -n kube-system alertmanager-0 50001:9093
```
Dans votre navigateur Web, accédez à la page http://localhost:50001.

Modifier la configuration de Prometheus Alertmanager

Vous pouvez modifier la configuration par défaut de Prometheus Alertmanager en modifiant le fichier monitoring.yaml de votre cluster d'utilisateur. Vous devez effectuer cette opération si vous souhaitez diriger les alertes vers une destination spécifique au lieu de les conserver dans le tableau de bord. Pour apprendre à configurer Alertmanager, consultez la documentation sur la configuration de Prometheus.

Pour modifier la configuration d'Alertmanager, procédez comme suit :

Créez une copie du fichier manifeste monitoring.yaml du cluster d'utilisateur :

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system \
   get monitoring monitoring-sample -o yaml > monitoring.yaml

Pour configurer Alertmanager, modifiez les champs sous spec.alertmanager.yml. Lorsque vous avez terminé, enregistrez le fichier manifeste modifié.

Appliquez le fichier manifeste à votre cluster :

kubectl apply --kubeconfig [USER_CLUSTER_KUBECONIFG] -f monitoring.yaml

Effectuer le scaling des ressources Prometheus

La configuration de la surveillance par défaut accepte jusqu'à cinq nœuds. Pour les clusters plus volumineux, vous pouvez ajuster les ressources du serveur Prometheus. Nous vous recommandons d'utiliser des cœurs de processeur de 50 milliCPU et 500 Mio de mémoire par nœud de cluster. Assurez-vous que votre cluster contient deux nœuds, chacun disposant de suffisamment de ressources pour s'adapter à Prometheus. Pour en savoir plus, consultez Redimensionner un cluster d'utilisateur.

Pour modifier les ressources du serveur Prometheus, procédez comme suit :

Créez une copie du fichier manifeste monitoring.yaml du cluster d'utilisateur :

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get monitoring monitoring-sample -o yaml > monitoring.yaml

Pour remplacer des ressources, modifiez les champs sous spec.resourceOverride. Lorsque vous avez terminé, enregistrez le fichier manifeste modifié. Exemple :

spec:
  resourceOverride:
  - component: Prometheus
    resources:
      requests:
        cpu: 300m
        memory: 3000Mi
      limits:
        cpu: 300m
        memory: 3000Mi

Appliquez le fichier manifeste à votre cluster :

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f monitoring.yaml

Créer un tableau de bord Grafana

Vous avez déployé une application qui expose une métrique et vérifié que celle-ci est exposée et que Prometheus l'extrait. Vous pouvez désormais ajouter la métrique au niveau de l'application dans un tableau de bord Grafana personnalisé.

Pour créer un tableau de bord Grafana, procédez comme suit :

Si nécessaire, accédez à Grafana.
Dans le tableau de bord de la page d'accueil, cliquez sur le menu déroulant Home (Accueil) dans l'angle supérieur gauche de la page.
Dans le menu de droite, cliquez sur New dashboard (Nouveau tableau de bord).
Dans la section New panel (Nouveau panneau), cliquez sur Graph (Graphique). Un tableau de bord de graphique vide s'affiche.
Cliquez sur Panel title (Titre du panneau), puis sur Edit (Modifier). Le panneau Graph (Graphique) du bas s'ouvre dans l'onglet Metrics (Métriques).
Dans le menu déroulant Data Source (Source de données), sélectionnez user (utilisateur). Cliquez sur Add query (Ajouter une requête), puis saisissez foo dans le champ search (recherche).
Cliquez sur le bouton Back to dashboard (Revenir au tableau de bord) dans l'angle supérieur droit de l'écran. Votre tableau de bord s'affiche.
Pour enregistrer le tableau de bord, cliquez sur Save dashboard (Enregistrer le tableau de bord) dans l'angle supérieur droit de l'écran. Choisissez un nom pour le tableau de bord, puis cliquez sur Save (Enregistrer).

Désactiver la surveillance au sein du cluster

Pour désactiver la surveillance au sein du cluster, annulez les modifications apportées à l'objet monitoring-sample :

Ouvrez l'objet monitoring-sample à modifier :
```
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG edit \
   monitoring monitoring-sample --namespace kube-system
```
Remplacez USER_CLUSTER_KUBECONFIG par le fichier kubeconfig de votre cluster d'utilisateur.

Pour désactiver Prometheus et Grafana, définissez enablePrometheus sur false.

   apiVersion: addons.k8s.io/v1alpha1
   kind: Monitoring
   metadata:
     labels:
       k8s-app: monitoring-operator
     name: monitoring-sample
     namespace: kube-system
   spec:
     channel: stable
     ...
     enablePrometheus: false

Fermez la session de modification pour enregistrer les modifications.
Vérifiez que les StatefulSets prometheus-0, prometheus-1 et grafana-0 ont été supprimés:
```
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get pods --namespace kube-system
```

Exemple : Ajouter des métriques au niveau de l'application dans un tableau de bord Grafana

Les sections suivantes vous expliquent comment ajouter des métriques pour une application. Dans cette section, vous allez effectuer les tâches suivantes :

Déployer un exemple d'application qui expose une métrique nommée foo
Vérifier que Prometheus expose et extrait la métrique
Créer un tableau de bord Grafana personnalisé

Déployer l'exemple d'application

L'exemple d'application s'exécute dans un seul pod. Le conteneur du pod affiche une métrique, foo, avec une valeur constante de 40.

Créez le fichier manifeste de pod suivant, pro-pod.yaml :

apiVersion: v1
kind: Pod
metadata:
  name: prometheus-example
  annotations:
    prometheus.io/scrape: 'true'
    prometheus.io/port: '8080'
    prometheus.io/path: '/metrics'
spec:
  containers:
  - image: registry.k8s.io/prometheus-dummy-exporter:v0.1.0
    name: prometheus-example
    command:
    - /bin/sh
    - -c
    - ./prometheus_dummy_exporter --metric-name=foo --metric-value=40 --port=8080

Appliquez ensuite le fichier manifeste du pod à votre cluster d'utilisateur :

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f pro-pod.yaml

Vérifier que la statistique est exposée et extraite

Le conteneur du pod prometheus-example écoute sur le port TCP 8080. Transférez un port local vers le port 8080 du pod :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-example 50002:8080
```
Pour vérifier que l'application expose la métrique, exécutez la commande suivante :
```
curl localhost:50002/metrics | grep foo
```
La commande renvoie le résultat suivant :
```
# HELP foo Custom metric
# TYPE foo gauge
foo 40
```
Le conteneur du pod prometheus-0 écoute sur le port TCP 9090. Transférez un port local vers le port 9090 du pod :
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-0 50003:9090
```
Pour vérifier que Prometheus extrait la métrique, accédez à la page http://localhost:50003/targets, qui doit vous rediriger vers le pod prometheus-0 du groupe cible prometheus-io-pods.
Pour afficher les métriques dans Prometheus, accédez à la page http://localhost:50003/graph. Dans le champ recherche, saisissez foo, puis cliquez sur Exécuter. La page doit afficher la métrique.