Pour en savoir plus sur les versions, consultez les notes de version de Distributed Cloud connecté.

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 :

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 .

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
edgecontainer.googleapis.com/Rack

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 sur les ressources `Rack`

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

Métrique	Description
`/router/bgp_up` Type : `GAUGE` Type : `BOOL`	Indique si la session d'appairage BGP sur le routeur est active et opérationnelle. `router_id` identifie le routeur spécifique (jusqu'à deux par rack).
`/router/connected` Type : `GAUGE` Type : `BOOL`	Indique si le routeur BGP est connecté à Google Cloud. `router_id` identifie le routeur spécifique (jusqu'à deux par rack).

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.

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

Créez le déploiement et le service :

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

Afficher les journaux d'application

Console

Dans la console Google Cloud , accédez à la page Explorateur de journaux.
Accéder à l'explorateur de journaux
Cliquez sur Ressource.
Dans la liste Tous les types de ressources, sélectionnez Kubernetes Container.
Pour Nom du cluster, sélectionnez le nom de votre cluster d'utilisateur.
Pour Nom de l'espace de noms, sélectionnez default.
Cliquez sur Ajouter, puis sur Exécuter la requête.

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

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.

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 .

Dans la console Google Cloud , accédez à la page Explorateur de métriques.
Accéder à l'explorateur de métriques
Pour Type de ressource, sélectionnez Kubernetes Pod.
Pour Métrique, sélectionnez external/prometheus/example_monitoring_up.
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: 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:
      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: metrics-providers-ca
              mountPath: /certs/metrics-providers
            - 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
            secretName: stackdriver-prometheus-scrape-cert
        - name: metrics-providers-ca
          secret:
            defaultMode: 420
            items:
            - key: ca.crt
              path: ca.crt
            secretName: metrics-providers-ca
        - 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 :

Pour envoyer des métriques à la fois à Cloud Monitoring et à Prometheus, utilisez les annotations décrites dans Exporter des journaux et des métriques personnalisés.
Pour n'envoyer des métriques qu'à Prometheus, utilisez les annotations suivantes :

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.

Étapes suivantes

Journaux d'audit

Journaux et métriques Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.