Activer la journalisation et la surveillance des applications

Version 1.12 

• Le plus récent
• Version 1.16
• Versions antérieures (non compatibles)

Cette page explique comment configurer un cluster pour les clusters Anthos sur solution Bare Metal afin que les journaux personnalisés et les métriques des applications utilisateur soient envoyés à Cloud Logging, Cloud Monitoring et Managed Service pour Prometheus.

Activer Managed Service pour Prometheus

Preview

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

La configuration de Managed Service pour Prometheus est spécifiée dans un objet Stackdriver nommé stackdriver. Pour en savoir plus, y compris sur les bonnes pratiques et le dépannage, consultez la documentation sur Managed Service pour Prometheus.

Pour configurer l'objet stackdriver afin d'activer Google Cloud Managed Service pour Prometheus, procédez comme suit :

1. Ouvrez l'objet Stackdriver pour le modifier :

   kubectl --kubeconfig=CLUSTER_KUBECONFIG \
       --namespace kube-system edit stackdriver stackdriver
   

   Remplacez CLUSTER_KUBECONFIG par le chemin d'accès du fichier kubeconfig de votre cluster.

2. Sous spec, définissez enableGMPForApplications sur true :

   apiVersion: addons.gke.io/v1alpha1
   kind: Stackdriver
   metadata:
     name: stackdriver
     namespace: kube-system
   spec:
     projectID: ...
     clusterName: ...
     clusterLocation: ...
     proxyConfigSecretName: ...
     enableGMPForApplications: true
     enableVPC: ...
     optimizedMetrics: true
   

3. Enregistrez et fermez le fichier modifié.

   Les composants Prometheus gérés par Google démarrent automatiquement dans le cluster dans l'espace de noms gmp-system.

4. Vérifiez les composants Prometheus gérés par Google :

   kubectl --kubeconfig=CLUSTER_KUBECONFIG --namespace gmp-system get pods
   

   La sortie de la commande ressemble à ceci :

   NAME                              READY   STATUS    RESTARTS        AGE
   collector-abcde                   2/2     Running   1 (5d18h ago)   5d18h
   collector-fghij                   2/2     Running   1 (5d18h ago)   5d18h
   collector-klmno                   2/2     Running   1 (5d18h ago)   5d18h
   gmp-operator-68d49656fc-abcde     1/1     Running   0               5d18h
   rule-evaluator-7c686485fc-fghij   2/2     Running   1 (5d18h ago)   5d18h
   

Managed Service pour Prometheus est compatible avec l'évaluation des règles et les alertes. Pour configurer l'évaluation des règles, consultez la page Évaluation des règles.

Exécuter un exemple d'application

Le service géré fournit un fichier manifeste pour un exemple d'application,prom-example qui émet des métriques Prometheus sur le port metrics. L'application utilise trois instances dupliquées.

Pour déployer l'application, procédez comme suit :

1. Créez l'espace de noms gmp-test pour les ressources que vous créez dans le cadre de l'exemple d'application :

   kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
   

2. Appliquez le fichier manifeste d'application à l'aide de la commande suivante :

   kubectl -n gmp-test apply \
       -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
   

Configurer une ressource PodMonitoring

Dans cette section, vous allez configurer une ressource personnalisée PodMonitoring pour capturer les données de métriques émises par l'exemple d'application et les envoyer à Managed Service pour Prometheus. La ressource personnalisée PodMonitoring utilise le scraping de cible. Dans ce cas, les agents de collecteur scrapent le point de terminaison /metrics vers lequel l'exemple d'application émet des données.

Une ressource personnalisée PodMonitoring scrape uniquement les cibles de l'espace de noms dans lequel elle est déployée. Pour scraper des cibles dans plusieurs espaces de noms, déployez la même ressource personnalisée PodMonitoring dans chaque espace de noms. Vous pouvez vérifier que la ressource PodMonitoring est installée dans l'espace de noms prévu en exécutant la commande suivante :

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

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.

Le fichier manifeste suivant définit une ressource PodMonitoring, prom-example, dans l'espace de noms gmp-test. La ressource trouve tous les pods de l'espace de noms qui portent le libellé app avec la valeur prom-example. Les pods correspondants sont détectés sur un port nommé metrics, toutes les 30 secondes, sur le chemin HTTP /metrics.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: prom-example
spec:
  selector:
    matchLabels:
      app: prom-example
  endpoints:
  - port: metrics
    interval: 30s

Pour appliquer cette ressource, exécutez la commande suivante :

kubectl --kubeconfig CLUSTER_KUBECONFIG -n gmp-test apply \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

Managed Service pour Prometheus récupère désormais les pods correspondants.

Données des métriques de requêtes

Le moyen le plus simple de vérifier que vos données Prometheus sont exportées consiste à utiliser des requêtes PromQL dans l'explorateur de métriques de la console Google Cloud.

Pour exécuter une requête PromQL, procédez comme suit:

1. Dans la console Google Cloud, accédez à la page Surveillance ou cliquez sur le bouton suivant :

   Accéder à Monitoring

2. Dans le volet de navigation, sélectionnez  Explorateur de métriques.

3. Utilisez le langage Prometheus Query Language (PromQL) pour spécifier les données à afficher sur le graphique:

   1. Dans la barre d'outils du volet Sélectionner une métrique, sélectionnez Éditeur de code.

   2. Sélectionnez PromQL dans les options du bouton Langage. Le bouton d'activation du langage se trouve en bas du volet Éditeur de code.

   3. Saisissez votre requête dans l'éditeur de requête. Par exemple, pour représenter le nombre moyen de secondes de CPU passées dans chaque mode au cours de la dernière heure, utilisez la requête suivante:

      avg(rate(kubernetes_io:anthos_container_cpu_usage_seconds_total
      {monitored_resource="k8s_node"}[1h]))
      

   Pour en savoir plus sur l'utilisation de PromQL, consultez PromQL dans Cloud Monitoring.

La capture d'écran suivante montre un graphique qui affiche la métrique anthos_container_cpu_usage_seconds_total:

Si vous collectez de grandes quantités de données, vous pouvez filtrer les métriques exportées afin de limiter les coûts.

Activer Cloud Logging pour les applications utilisateur

Preview

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

La configuration de Cloud Logging et Cloud Monitoring se trouve dans un objet Stackdriver nommé stackdriver.

1. Ouvrez l'objet Stackdriver pour le modifier :

   kubectl --kubeconfig=CLUSTER_KUBECONFIG \
       --namespace kube-system edit stackdriver stackdriver
   

   Remplacez CLUSTER_KUBECONFIG par le chemin d'accès du fichier kubeconfig de votre cluster d'utilisateur.

2. Dans la section spec, définissez enableCloudLoggingForApplications sur true :

   apiVersion: addons.gke.io/v1alpha1
     kind: Stackdriver
     metadata:
       name: stackdriver
       namespace: kube-system
     spec:
       projectID: ...
       clusterName: ...
       clusterLocation: ...
       proxyConfigSecretName: ...
       enableCloudLoggingForApplications: true
       enableVPC: ...
       optimizedMetrics: true
   

3. Enregistrez et fermez le fichier modifié.

Exécuter un exemple d'application

Dans cette section, vous allez créer une application qui écrit des journaux personnalisés.

1. Enregistrez les fichiers manifestes de déploiement suivant dans un fichier nommé my-app.yaml.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: "monitoring-example"
     namespace: "default"
     labels:
       app: "monitoring-example"
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: "monitoring-example"
     template:
       metadata:
         labels:
           app: "monitoring-example"
       spec:
         containers:
         - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
           name: prometheus-example-exporter
           imagePullPolicy: Always
           command:
           - /bin/sh
           - -c
           - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
           resources:
             requests:
               cpu: 100m
   

2. Créer le déploiement

   kubectl --kubeconfig CLUSTER_KUBECONFIG apply -f my-app.yaml
   

Afficher les journaux d'application

Console

1. Accédez à l'explorateur de journaux dans la console Google Cloud.

   Accéder à l'explorateur de journaux

2. Cliquez sur Ressource. Dans le menu TOUS LES TYPES DE RESSOURCES, sélectionnez Conteneur Kubernetes.

3. Sous CLUSTER_NAME, sélectionnez le nom de votre cluster d'utilisateur.

4. Sous NAMESPACE_NAME, sélectionnez default.

5. Cliquez sur Ajouter, puis sur Exécuter la requête.

6. Les entrées de journal du déploiement monitoring-example sont affichées sous Résultats de la requête. Exemple :

   {
     "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
     "insertId": "1oa4vhg3qfxidt",
     "resource": {
       "type": "k8s_container",
       "labels": {
         "pod_name": "monitoring-example-7685d96496-xqfsf",
         "cluster_name": ...,
         "namespace_name": "default",
         "project_id": ...,
         "location": "us-west1",
         "container_name": "prometheus-example-exporter"
       }
     },
     "timestamp": "2020-11-14T01:24:24.358600252Z",
     "labels": {
       "k8s-pod/pod-template-hash": "7685d96496",
       "k8s-pod/app": "monitoring-example"
     },
     "logName": "projects/.../logs/stdout",
     "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
   }
   

gcloud CLI

1. Exécutez cette commande :

   gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
       resource.type="k8s_container" AND resource.labels.namespace_name="default"'
   

   Remplacez PROJECT_ID par l'ID de votre projet.

2. Le résultat affiche les entrées de journal du déploiement monitoring-example. Exemple :

   insertId: 1oa4vhg3qfxidt
   labels:
     k8s-pod/app: monitoring-example
     k8s- pod/pod-template-hash: 7685d96496
   logName: projects/.../logs/stdout
   receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
   resource:
     labels:
       cluster_name: ...
       container_name: prometheus-example-exporter
       location: us-west1
       namespace_name: default
       pod_name: monitoring-example-7685d96496-xqfsf
       project_id: ...
     type: k8s_container
   textPayload: |
     2020/11/14 01:24:24 Starting to listen on :9090
   timestamp: '2020-11-14T01:24:24.358600252Z'
   

Activer Logging et Monitoring pour les applications utilisateur (ancien)

Pour activer Logging et Monitoring pour vos applications, utilisez le champ spec.clusterOperations.enableApplication dans le fichier de configuration du cluster.

1. Mettez à jour le fichier de configuration du cluster pour définir enableApplication sur true :

   apiVersion: v1
   kind: Namespace
   metadata:
     name: cluster-user-basic
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: user-basic
     namespace: cluster-user-basic
   spec:
     type: user
     ...
     clusterOperations:
       projectID: project-fleet
       location: us-central1
       enableApplication: true
       ...
   

2. Utilisez bmctl update pour appliquer vos modifications :

   bmctl update cluster -c CLUSTER_NAME --admin-kubeconfig=ADMIN_KUBECONFIG
   

   Remplacez les éléments suivants :

   • CLUSTER_NAME : nom du cluster à mettre à niveau.
   • ADMIN_KUBECONFIG : chemin d'accès au fichier kubeconfig du cluster d'administrateur.

Annoter des charges de travail

Pour activer la collecte de métriques personnalisées à partir d'une application, ajoutez l'annotation prometheus.io/scrape: "true" au fichier manifeste du service ou du pod de l'application, ou ajoutez la même annotation à la section spec.template dans le fichier manifeste "Déploiement" ou DaemonSet afin qu'elles soient transmises à leurs pods.

Exécuter un exemple d'application

Dans cette section, vous allez créer une application qui écrit des journaux personnalisés et expose une métrique personnalisée.

1. Enregistrez les fichiers manifeste de service et de déploiement suivants dans un fichier nommé my-app.yaml. Notez que le service possède l'annotation prometheus.io/scrape: "true" :

   kind: Service
   apiVersion: v1
   metadata:
     name: "monitoring-example"
     namespace: "default"
     annotations:
       prometheus.io/scrape: "true"
   spec:
     selector:
       app: "monitoring-example"
     ports:
       - name: http
         port: 9090
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: "monitoring-example"
     namespace: "default"
     labels:
       app: "monitoring-example"
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: "monitoring-example"
     template:
       metadata:
         labels:
           app: "monitoring-example"
       spec:
         containers:
         - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
           name: prometheus-example-exporter
           imagePullPolicy: Always
           command:
           - /bin/sh
           - -c
           - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
           resources:
             requests:
               cpu: 100m
   

2. Créez le déploiement et le service :

   kubectl --kubeconfig CLUSTER_KUBECONFIG apply -f my-app.yaml
   

Afficher les journaux d'application

Console

1. Accédez à l'explorateur de journaux dans la console Google Cloud.

   Accéder à l'explorateur de journaux

2. Cliquez sur Ressource. Sous TOUS LES TYPES DE RESSOURCES, sélectionnez Conteneur Kubernetes.

3. Sous CLUSTER_NAME, sélectionnez le nom de votre cluster d'utilisateur.

4. Sous NAMESPACE_NAME, sélectionnez default.

5. Cliquez sur Ajouter, puis sur Exécuter la requête.

6. Les entrées de journal du déploiement monitoring-example sont affichées sous Résultats de la requête. Exemple :

   {
     "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
     "insertId": "1oa4vhg3qfxidt",
     "resource": {
       "type": "k8s_container",
       "labels": {
         "pod_name": "monitoring-example-7685d96496-xqfsf",
         "cluster_name": ...,
         "namespace_name": "default",
         "project_id": ...,
         "location": "us-west1",
         "container_name": "prometheus-example-exporter"
       }
     },
     "timestamp": "2020-11-14T01:24:24.358600252Z",
     "labels": {
       "k8s-pod/pod-template-hash": "7685d96496",
       "k8s-pod/app": "monitoring-example"
     },
     "logName": "projects/.../logs/stdout",
     "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
   }
   

gcloud CLI

1. Exécutez cette commande :

   gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
       resource.type="k8s_container" AND resource.labels.namespace_name="default"'
   

   Remplacez PROJECT_ID par l'ID de votre projet.

2. Le résultat affiche les entrées de journal du déploiement monitoring-example. Exemple :

   insertId: 1oa4vhg3qfxidt
   labels:
     k8s-pod/app: monitoring-example
     k8s- pod/pod-template-hash: 7685d96496
   logName: projects/.../logs/stdout
   receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
   resource:
     labels:
       cluster_name: ...
       container_name: prometheus-example-exporter
       location: us-west1
       namespace_name: default
       pod_name: monitoring-example-7685d96496-xqfsf
       project_id: ...
     type: k8s_container
   textPayload: |
     2020/11/14 01:24:24 Starting to listen on :9090
   timestamp: '2020-11-14T01:24:24.358600252Z'
   

Afficher les métriques de l'application dans Google Cloud Console

Votre exemple d'application présente une métrique personnalisée nommée example_monitoring_up. Vous pouvez consulter les valeurs de cette métrique dans la console Google Cloud.

1. Accédez à l'explorateur de métriques dans la console Google Cloud.

   Accéder à l'explorateur de métriques

2. Dans le champ Type de ressource, sélectionnez Kubernetes Pod ou Kubernetes Container.

3. Pour Métrique, sélectionnez external.googleapis.com/prometheus/example_monitoring_up.

4. Le graphique montre que example_monitoring_up a une valeur répétée de 1.