Journalisation et surveillance des applications

Cette page explique comment configurer un cluster d'utilisateur pour Anthos clusters on VMware (GKE On-Prem) afin que les journaux personnalisés et les métriques des applications utilisateur soient envoyés à Cloud Logging et à Cloud Monitoring.

Vous pouvez également surveiller vos charges de travail à l'aide de Google Cloud Managed Service pour Prometheus. Il s'agit du service de stockage et de requête entièrement géré de Google Cloud pour les métriques Prometheus. Pour utiliser cette fonctionnalité, activez Managed Service pour Prometheus et Cloud Logging en suivant les étapes ci-dessous.

Activer Managed Service pour Prometheus pour les applications utilisateur

La configuration de Managed Service pour Prometheus est stockée dans un objet Stackdriver nommé stackdriver.

  1. Ouvrez l'objet stackdriver à modifier :

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

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

  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. Fermez le fichier modifié. Cette opération démarre l'exécution des composants Prometheus gérés par Google (GMP) dans le cluster.

  4. Pour vérifier les composants, exécutez la commande suivante :

    kubectl --kubeconfig=USER_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

Dans cette section, vous allez créer une application qui émet des métriques Prometheus et utiliser le service Prometheus géré par Google pour collecter les métriques. Pour en savoir plus, consultez la page Google Cloud Managed Service pour Prometheus.

Déployer l'exemple d'application

  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=USER_CLUSTER_KUBECONFIG create ns gmp-test
    
  2. Le service géré fournit un fichier manifeste pour un exemple d'application qui émet des métriques Prometheus sur le port metrics. L'application utilise trois instances dupliquées.

    Pour déployer l'exemple d'application, exécutez la commande suivante :

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

Configurer une ressource PodMonitoring

Pour ingérer les données de métriques émises par l'exemple d'application, vous utilisez le scraping de données cibles. Le service géré utilise des ressources personnalisées PodMonitoring pour configurer le scraping et l'ingestion de métriques cibles. Vous pouvez convertir les ressources prometheus-operator existantes en ressources personnalisées PodMonitoring.

Une RS PodMonitoring ne scrape les cibles que dans l'espace de noms dans lequel la RS est déployée. Pour scraper des cibles dans plusieurs espaces de noms, déployez la même RS 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 USER_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 récupéré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 USER_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:

Graphique de Managed Service pour Prometheus pour la métrique Prometheus "anthos_container_cpu_usage_seconds_total".

Si vous collectez un grand nombre de données, vous pouvez filtrer les métriques exportées afin de limiter les coûts.

Activer Cloud Logging pour les applications utilisateur

La configuration de Logging est stockée dans un objet Stackdriver nommé stackdriver.

  1. Ouvrez l'objet stackdriver à modifier :

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

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

  2. Sous 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. 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 le fichier de manifeste 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éez le déploiement :

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

Afficher des 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 ALL_RESOURCE_TYPES, sélectionnez Kubernetes Container.

  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

  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 de journalisation et de surveillance.

  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 la journalisation et la surveillance pour les applications utilisateur (ancien)

Notez que nous vous recommandons vivement d'utiliser le champ Stackdriver CR enableGMPForApplications et enableCloudLoggingForApplications ci-dessus pour activer la surveillance et la journalisation des applications utilisateur.

Les étapes suivantes fonctionnent toujours, mais ne sont pas recommandées. Veuillez lire ce problème connu avant de suivre les étapes ci-dessous.

Cette section explique comment activer Logging et Monitoring si vous n'utilisez pas Managed Service pour Prometheus. La configuration de Logging et Monitoring se trouve dans un objet Stackdriver nommé stackdriver.

  1. Ouvrez l'objet stackdriver à modifier :

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

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

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

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        proxyConfigSecretName: ...
        enableStackdriverForApplications: true
        enableVPC: ...
        optimizedMetrics: true
    
  3. Fermez le fichier modifié.

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.

Pour éviter la récupération de mémoire de métriques, nous vous recommandons de définir l'intervalle de scraping des métriques sur une minute.

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 USER_CLUSTER_KUBECONFIG apply -f my-app.yaml
    

Afficher des 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 ALL_RESOURCE_TYPES, sélectionnez Kubernetes Container.

  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

  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 de journalisation et de surveillance.

  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.