Journaux et métriques

Cette page explique comment Google Distributed Cloud Connected enregistre différents types d'informations sur son fonctionnement et comment les afficher. La collecte de certains types de journaux et de métriques entraîne des frais supplémentaires. Pour en savoir plus, consultez Facturation des journaux et des métriques.

Configurer la journalisation et la surveillance

Avant de pouvoir commencer à collecter des journaux et des métriques, vous devez effectuer les opérations suivantes :

  1. Activez les API de journalisation à l'aide des commandes suivantes :

    gcloud services enable opsconfigmonitoring.googleapis.com --project PROJECT_ID
gcloud services enable logging.googleapis.com --project PROJECT_ID
gcloud services enable monitoring.googleapis.com --project PROJECT_ID

    Remplacez PROJECT_ID par l'ID du projet cible Google Cloud .

  2. Attribuez les rôles requis pour écrire des journaux et des métriques :

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/opsconfigmonitoring.resourceMetadata.writer \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/metadata-agent]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/logging.logWriter \
     --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver-log-forwarder]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/monitoring.metricWriter \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/gke-metrics-agent]"

    Remplacez PROJECT_ID par l'ID du projet cible Google Cloud .

Journaux

Cette section liste les types de ressources Cloud Logging compatibles avec Distributed Cloud. Pour afficher les journaux Distributed Cloud, utilisez l'explorateur de journaux dans la console Google Cloud . La journalisation Distributed Cloud est toujours activée.

Les types de ressources enregistrées connectées à Distributed Cloud sont les ressources Kubernetes standards suivantes :

  • k8s_container
  • k8s_node

Vous pouvez également capturer et récupérer les journaux connectés Distributed Cloud à l'aide de l'API Cloud Logging. Pour savoir comment configurer ce mécanisme de journalisation, consultez la documentation sur les bibliothèques clientes Cloud Logging.

Métriques

Cette section liste les métriques Cloud Monitoring compatibles avec Distributed Cloud. Pour afficher les métriques Distributed Cloud, utilisez l'explorateur de métriques dans la consoleGoogle Cloud .

Métriques des clusters Distributed Cloud connecté

Pour les clusters Distributed Cloud connecté, Distributed Cloud connecté fournit les types de métriques suivants générés par les nœuds Distributed Cloud connecté :

  • Les métriques sur les ressources fournissent des informations sur les performances des nœuds et des pods connectés Distributed Cloud, telles que la charge du processeur et l'utilisation de la mémoire.
  • Les métriques des applications système fournissent des informations sur les charges de travail du système Distributed Cloud connecté, telles que coredns.

Pour obtenir la liste de ces métriques, consultez Métriques Google Distributed Cloud et Google Distributed Cloud.

Le Cloud distribué connecté ne fournit pas de métriques générées par les plans de contrôle Kubernetes associés aux clusters Cloud distribué connecté.

Métriques du matériel connecté Distributed Cloud

Distributed Cloud connected fournit des métriques pour le matériel Distributed Cloud connected à l'aide des types de ressources suivants :

  • edgecontainer.googleapis.com/Machine

Métriques sur les ressources Machine

Distributed Cloud connected écrit les métriques de l'API Cloud Monitoring suivantes pour la ressource edgecontainer.googleapis.com/Machine :

Métrique Description
/machine/cpu/total_cores
  • Type : GAUGE
  • Type : INT
 Nombre total de cœurs de processeur physiques présents sur la machine.
/machine/cpu/usage_time
  • Type : CUMULATIVE
  • Type : DOUBLE
  • Unité : Seconds
 Temps d'utilisation cumulé du processeur pour tous les cœurs de la machine. Le type peut être workload (charges de travail client) ou system (tout le reste).
/machine/cpu/utilization
  • Type : GAUGE
  • Type : DOUBLE
 Pourcentage d'utilisation du processeur sur la machine. La plage de valeurs s'étend de 0 à 1. Le type peut être workload (charges de travail client) ou system (tout le reste).
/machine/memory/total_bytes
  • Type : GAUGE
  • Type : INT64
 Nombre d'octets de la mémoire totale de la machine.
/machine/memory/used_bytes
  • Type : GAUGE
  • Type : INT64
 Nombre d'octets de mémoire utilisée sur la machine. memory_type est evictable (récupérable par le noyau) ou non-evictable (non récupérable).
/machine/memory/utilization
  • Type : GAUGE
  • Type : DOUBLE
 Pourcentage d'utilisation de la mémoire sur la machine. La plage de valeurs s'étend de 0 à 1. memory_type correspond à evictable (récupérable par le noyau) ou non-evictable (non récupérable).
/machine/network/up
  • Type : GAUGE
  • Type : BOOL
 Indique si l'interface réseau est opérationnelle. Inclut les cartes principales, les cartes secondaires et les ports.
/machine/network/link_speed
  • Type : GAUGE
  • Type : DOUBLE
  • Unité : octets par seconde
 Vitesse de liaison de la carte d'interface réseau principale.
/machine/network/received_bytes_count
  • Type : CUMULATIVE
  • Type : DOUBLE
 Nombre d'octets reçus pour la carte d'interface réseau principale.
/machine/network/sent_bytes_count
  • Type : CUMULATIVE
  • Type : DOUBLE
 Nombre d'octets envoyés pour la carte d'interface réseau principale.
/machine/network/connectivity
  • Type : GAUGE
  • Type : BOOL
 Indique si la carte d'interface réseau principale est connectée à Internet.
/machine/disk/total_bytes
  • Type : GAUGE
  • Type : INT64
 Nombre d'octets de l'espace disque total sur la machine.
/machine/disk/used_bytes
  • Type : GAUGE
  • Type : INT64
 Nombre d'octets d'espace disque utilisé sur la machine.
/machine/disk/utilization
  • Type : GAUGE
  • Type : DOUBLE
 Pourcentage d'utilisation de l'espace disque sur la machine. La plage de valeurs s'étend de 0 à 1.
/machine/restart_count
  • Type : CUMULATIVE
  • Type : INT
 Nombre de redémarrages de la machine.
/machine/uptime
  • Type : GAUGE
  • Type : INT
  • Unité : Seconds
 Temps d'activité de la machine depuis le dernier redémarrage.
/machine/connected
  • Type : GAUGE
  • Type : INT64
 Indique si la machine est connectée à Google Cloud.

Métriques des opérations de sauvegarde des machines virtuelles

Distributed Cloud Connected collecte et exporte les métriques suivantes liées à l'agent de sauvegarde de la machine virtuelle :

Métrique Description
gdc_backup_backups_completed
  • Type : COUNTER
 Nombre de sauvegardes de machines virtuelles effectuées avec succès.
gdc_backup_backups_latency
  • Type : HISTOGRAM
 Latence des sauvegardes de machines virtuelles, en minutes.
gdc_backup_volume_backups_created
  • Type : COUNTER
 Nombre de sauvegardes de volumes créées à ce jour.
gdc_backup_volume_backups_completed
  • Type : COUNTER
 Nombre de sauvegardes de volumes effectuées à ce jour.
gdc_backup_restores_completed
  • Type : COUNTER
 Nombre de restaurations de machines virtuelles effectuées à ce jour.
gdc_backup_restores_latency
  • Type : HISTOGRAM
 Latence de la restauration de la machine virtuelle, en minutes.
gdc_backup_volume_restores_created
  • Type : COUNTER
 Nombre de restaurations de volumes créées à ce jour.
gdc_backup_volume_restores_completed
  • Type : COUNTER
 Nombre de restaurations de volumes effectuées à ce jour.

Le Cloud distribué connecté collecte et exporte les métriques suivantes liées au plan de contrôle de sauvegarde des machines virtuelles :

Métrique Description
gdc_backup_controlplane_live
  • Type : GAUGE
 Indique si le plan de contrôle de sauvegarde est opérationnel.
gdc_backup_backup_repositories_attached
  • Type : GAUGE
 Nombre de dépôts de sauvegarde associés.
gdc_backup_backups_created
  • Type : COUNTER
 Nombre de sauvegardes de machines virtuelles créées à ce jour.
gdc_backup_backups_deleted
  • Type : COUNTER
 Nombre de sauvegardes de machines virtuelles supprimées à ce jour.
gdc_backup_restores_created
  • Type : COUNTER
 Nombre de restaurations de machines virtuelles créées à ce jour.
gdc_gdc_backup_backups_pile_up
  • Type : GAUGE
 Indique si un plan de sauvegarde a atteint sa limite de nombre de sauvegardes en cours.

Distributed Cloud connected collecte et exporte les métriques suivantes liées à la facturation de la fonctionnalité de sauvegarde des machines virtuelles :

Métrique Description
metering_protected_resources_total
  • Source : agent de sauvegarde de VM
  • Type : COUNTER
 Nombre total de machines virtuelles sauvegardées à ce jour.
metering_deleted_resources_total
  • Source : plan de contrôle de la sauvegarde de VM
  • Type : COUNTER
 Nombre total de sauvegardes de machines virtuelles supprimées à ce jour.

Exporter des journaux et des métriques d'application personnalisés

Distributed Cloud connected exporte automatiquement les journaux des applications exécutées sur les charges de travail Distributed Cloud connected. Pour exporter des métriques pour une application s'exécutant sur des charges de travail connectées Distributed Cloud, vous devez l'annoter comme décrit dans la section suivante.

Annoter la charge de travail pour activer l'exportation des métriques

Pour activer la collecte de métriques personnalisées à partir d'une application, ajoutez les annotations suivantes au fichier manifeste de service ou de déploiement de l'application :

  • prometheus.io/scrape: "true"
  • prometheus.io/path: "ENDPOINT_PATH". Remplacez ENDPOINT_PATH par le chemin d'accès complet au point de terminaison des métriques de l'application cible.
  • prometheus.io/port: "PORT_NUMBER" : port sur lequel le point de terminaison des métriques de l'application écoute les connexions.

Exécuter un exemple d'application

Dans cette section, vous allez créer une application qui écrit des journaux personnalisés et expose un point de terminaison de 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 apply -f my-app.yaml

Afficher les journaux d'application

Console

  1. Dans la console Google Cloud , accédez à la page Explorateur de journaux.

    Accéder à l'explorateur de journaux

  2. Cliquez sur Ressource.

  3. Dans la liste Tous les types de ressources, sélectionnez Kubernetes Container.

  4. Pour Nom du cluster, sélectionnez le nom de votre cluster d'utilisateur.

  5. Pour Nom de l'espace de noms, sélectionnez default.

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

  7. Les entrées de journal du déploiement monitoring-example sont affichées dans la section 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 la commande gcloud logging read :

    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 d'application

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. Dans la console Google Cloud , accédez à la page Explorateur de métriques.

    Accéder à l'explorateur de métriques

  2. Pour Type de ressource, sélectionnez Kubernetes Pod.

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

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

Collecter des métriques avec Prometheus

Distributed Cloud Connected est compatible avec la solution de métriques Prometheus pour collecter des métriques sur vos charges de travail Distributed Cloud Connected.

À cette fin, Distributed Cloud Connected crée un espace de noms non géré nommé prom-monitoring lorsque vous créez un cluster Distributed Cloud Connected. Nous vous recommandons d'utiliser cet espace de noms pour déployer Prometheus. Vous pouvez également copier les ressources requises de l'espace de noms prom-monitoring vers l'espace de noms de votre choix et y déployer Prometheus.

Configurer le scraping des métriques Prometheus

Pour collecter des métriques Distributed Cloud connectées avec Prometheus, vous devez configurer le scraping des métriques Prometheus. Pour ce faire, installez l'objet ConfigMap prometheus-scrape-config dans votre pod Prometheus et ajoutez la configuration de récupération à partir de ConfigMap à votre configuration Prometheus. Exemple :

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus-local-rolebinding
  namespace: prom-monitoring
subjects:
- kind: ServiceAccount
  name: prometheus-scrape
  namespace: prom-monitoring
roleRef:
  kind: ClusterRole
  name: gke-metrics-agent
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: prom-monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 5s
      evaluation_interval: 5s
    rule_files:
    scrape_config_files:
    - /etc/prometheus/scrape/*.yml
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: prom-monitoring
spec:
  selector:
    app: prom-monitoring
  ports:
  - port: 9090
    targetPort: 9090
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-deployment
  namespace: prom-monitoring
  labels:
    app: prom-monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prom-monitoring
  template:
    metadata:
      labels:
        app: prom-monitoring
    spec:
      serviceAccountName: prometheus-scrape
      containers:
        - name: prometheus
          image: prom/prometheus:main
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--storage.tsdb.path=/prometheus/"
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-scrape-config-volume
              mountPath: /etc/prometheus/scrape/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
            - name: prometheus-scrape-token
              mountPath: /var/run/secrets/kubernetes.io/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-scrape-cert
              mountPath: /certs/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-etcd-scrape
              mountPath: /stackdriver-prometheus-etcd-scrape
      volumes:
        - name: prometheus-storage-volume
          emptyDir: {}
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-config
        - name: prometheus-scrape-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-scrape-config
        - name: prometheus-scrape-token
          secret:
            defaultMode: 420
            secretName: prometheus-scrape
        - name: stackdriver-prometheus-scrape-cert
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-scrape-cert
        - name: stackdriver-prometheus-etcd-scrape
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-etcd-scrape

Pour collecter des métriques de charge de travail avec Prometheus, vous devez ajouter des annotations aux services et aux pods exécutant les charges de travail cibles comme suit :

prometheus.io/unmanaged_scrape: "true"
prometheus.io/unmanaged_path: "ENDPOINT_PATH"
prometheus.io/unmanaged_port: "PORT_NUMBER"

Collecter des journaux avec Kafka

Distributed Cloud connecté est compatible avec la solution Apache Kafka pour la collecte des journaux sur les charges de travail exécutées sur votre déploiement Distributed Cloud connecté.

Vous devez disposer d'un déploiement Kafka fonctionnel avant de suivre les étapes de cette section. Vos courtiers Kafka doivent annoncer leurs écouteurs en mode PLAINTEXT. Les variables liées à SSL/SASL ne sont pas prises en charge.

Pour configurer un cluster pour la journalisation Kafka, vous devez créer un fichier JSON qui configure les modules complémentaires que vous souhaitez exécuter sur le cluster. Spécifiez ce fichier lorsque vous créez un cluster à l'aide de l'option --system-addons-config. Si vous devez modifier la configuration Kafka, vous devez supprimer le cluster et le recréer avec les nouveaux paramètres Kafka.

Ajoutez la section suivante au fichier de configuration des modules complémentaires système :

{
        "systemAddonsConfig": {
          "unmanagedKafkaConfig": {
            "brokers": "BROKERS",
            "topics": "TOPICS"
     "topic_key": "TOPIC_KEY, 
          }
      }
}

Remplacez les éléments suivants :

  • BROKERS : liste de paires d'adresses IP et de ports de broker séparées par une virgule au format ip_address:port.
  • TOPICS : liste de sujets Kafka, séparés par une virgule.
  • TOPIC_KEY : clé de sujet Kafka. Cela permet à Kafka de sélectionner un sujet si plusieurs existent.

Si Kafka ne collecte pas les journaux après la création de votre cluster connecté Distributed Cloud, vérifiez les points suivants :

  • Côté serveur : consultez les journaux d'erreurs de votre déploiement Kafka pour identifier un éventuel problème.
  • Côté client : contactez l'assistance Google pour récupérer et examiner les journaux des pods système.

Collecter les journaux bruts des charges de travail pour traitement externe

Vous pouvez configurer Distributed Cloud Connected pour exporter les journaux bruts (non traités et non tagués) des pods de charge de travail vers /var/logs/export, ce qui vous permet d'utiliser votre propre collecteur de journaux pour le traitement des journaux.

Pour configurer l'exportation des journaux bruts de charge de travail, créez une ressource personnalisée LogExport avec le contenu suivant, puis appliquez-la à votre cluster :

apiVersion: gdc.addons.gke.io/v1
kind: LogExport
metadata:
  name: my-log-export
spec:
  namespaces:
  - namespace1
  - namespace2
  - namespace3

Dans le champ namespaces, listez les espaces de noms de charge de travail pour lesquels vous souhaitez exporter les journaux de pod bruts. Le champ n'accepte pas les espaces de noms système, tels que ceux listés dans Restrictions concernant les espaces de noms de gestion.

Étapes suivantes