Cette page a été traduite par l'API Cloud Translation.

Déployer le collecteur OpenTelemetry conçu par Google sur Google Kubernetes Engine
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce document explique comment exécuter le collecteur OpenTelemetry construit par Google sur Google Kubernetes Engine pour collecter les journaux, les métriques et les traces OTLP à partir d'applications instrumentées, puis exporter ces données vers Google Cloud.

Avant de commencer

L'exécution du collecteur OpenTelemetry créé par Google nécessite les ressources suivantes:

Un projet Google Cloud avec l'API Cloud Monitoring, l'API Cloud Trace et l'API Cloud Logging activées.
- Si vous n'avez pas de projet Google Cloud, procédez comme suit :
  1. Dans la console Google Cloud, accédez à Nouveau projet :
    
    Créer un projet
  2. Dans le champ Nom du projet, saisissez un nom pour votre projet, puis cliquez sur Créer.
  3. Accéder à la page Facturation :
    
    Accéder à Facturation
  4. Sélectionnez le projet que vous venez de créer s'il n'est pas déjà sélectionné en haut de la page.
  5. Vous êtes invité à choisir un profil de paiement existant ou à en créer un.
  L'API Monitoring, l'API Trace et l'API Logging sont activées par défaut pour les nouveaux projets.
- Si vous disposez déjà d'un projet Google Cloud, assurez-vous que l'API Monitoring, l'API Trace et l'API Logging sont activées:
  
  Enable the APIs
Un cluster Kubernetes. Si vous ne disposez pas de cluster Kubernetes, suivez les instructions du guide de démarrage rapide pour GKE.
Les outils de ligne de commande suivants :
- gcloud
- kubectl
Les outils gcloud et kubectl font partie de Google Cloud CLI. Pour en savoir plus sur leur installation, consultez la section Gérer les composants de Google Cloud CLI. Pour afficher les composants de la CLI gcloud que vous avez installés, exécutez la commande suivante:
```
gcloud components list
```

Configurer les autorisations du collecteur

Si vous avez désactivé l'identité de charge de travail GKE, vous pouvez ignorer cette section.

Pour vous assurer que le compte de service Kubernetes du collecteur OpenTelemetry dispose des autorisations nécessaires pour exporter les données de télémétrie, demandez à votre administrateur d'accorder au compte de service Kubernetes du collecteur OpenTelemetry les rôles IAM suivants sur votre projet:

Rédacteur de métriques Monitoring (roles/monitoring.metricWriter)
Logging Log Writer (Rédacteur de journaux de journalisation) (roles/logging.logWriter)
Agent Cloud Trace (roles/cloudtrace.agent)

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Votre administrateur peut également attribuer au compte de service Kubernetes du collecteur OpenTelemetry les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Pour configurer les autorisations, utilisez les commandes add-iam-policy-binding suivantes:

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/logging.logWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/monitoring.metricWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/cloudtrace.agent \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector

Avant d'exécuter les commandes, remplacez les variables suivantes:

PROJECT_ID: identifiant du projet.
PROJECT_NUMBER : numéro de projet Google Cloud.

Déployer le collecteur

Le pipeline de collecteur peut être déployé directement à partir des exemples validés fournis par le dépôt d'ingestion Kubernetes OTLP autogéré. Vous pouvez déployer directement à partir de GitHub avec les commandes suivantes, en remplaçant PROJECT_ID par l'ID de votre Google Cloud projet:

export GCLOUD_PROJECT=PROJECT_ID
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest.git/k8s/base | envsubst | kubectl apply -f -

Avant d'exécuter les commandes, remplacez la variable suivante:

PROJECT_ID: identifiant du projet.

Configurer le collecteur

Nous vous fournissons une configuration de collecteur OpenTelemetry à utiliser avec le collecteur Google. Cette configuration est conçue pour fournir de grands volumes de métriques, de journaux et de traces OTLP avec des métadonnées GKE et Kubernetes cohérentes. Cette configuration est également conçue pour éviter les problèmes d'ingestion courants. Vous pouvez ajouter des éléments à la configuration, mais nous vous recommandons vivement de ne pas en supprimer.

Cette section décrit la configuration fournie, les principaux composants tels que les exportateurs, les processeurs, les récepteurs et les autres composants disponibles.

Configuration du collecteur fournie

Vous trouverez la configuration du collecteur pour les environnements Kubernetes dans le dépôt otlp-k8s-ingest:

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

exporters:
  googlecloud:
    log:
      default_log_name: opentelemetry-collector
    user_agent: Google-Cloud-OTLP manifests:0.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)

extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
processors:
  filter/self-metrics:
    metrics:
      include:
        match_type: strict
        metric_names:
        - otelcol_process_uptime
        - otelcol_process_memory_rss
        - otelcol_grpc_io_client_completed_rpcs
        - otelcol_googlecloudmonitoring_point_count
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  k8sattributes:
    extract:
      metadata:
      - k8s.namespace.name
      - k8s.deployment.name
      - k8s.statefulset.name
      - k8s.daemonset.name
      - k8s.cronjob.name
      - k8s.job.name
      - k8s.replicaset.name
      - k8s.node.name
      - k8s.pod.name
      - k8s.pod.uid
      - k8s.pod.start_time
    passthrough: false
    pod_association:
    - sources:
      - from: resource_attribute
        name: k8s.pod.ip
    - sources:
      - from: resource_attribute
        name: k8s.pod.uid
    - sources:
      - from: connection
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  metricstransform/self-metrics:
    transforms:
    - action: update
      include: otelcol_process_uptime
      operations:
      - action: add_label
        new_label: version
        new_value: Google-Cloud-OTLP manifests:0.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)

  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  transform/collision:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["exported_location"], attributes["location"])
      - delete_key(attributes, "location")
      - set(attributes["exported_cluster"], attributes["cluster"])
      - delete_key(attributes, "cluster")
      - set(attributes["exported_namespace"], attributes["namespace"])
      - delete_key(attributes, "namespace")
      - set(attributes["exported_job"], attributes["job"])
      - delete_key(attributes, "job")
      - set(attributes["exported_instance"], attributes["instance"])
      - delete_key(attributes, "instance")
      - set(attributes["exported_project_id"], attributes["project_id"])
      - delete_key(attributes, "project_id")

  # The relative ordering of statements between ReplicaSet & Deployment and Job & CronJob are important.
  # The ordering of these controllers is decided based on the k8s controller documentation available at
  # https://kubernetes.io/docs/concepts/workloads/controllers.
  # The relative ordering of the other controllers in this list is inconsequential since they directly
  # create pods.
  transform/aco-gke:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["top_level_controller_type"], "ReplicaSet") where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.replicaset.name"]) where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_type"], "Deployment") where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.deployment.name"]) where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_type"], "DaemonSet") where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.daemonset.name"]) where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_type"], "StatefulSet") where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.statefulset.name"]) where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_type"], "Job") where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.job.name"]) where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_type"], "CronJob") where resource.attributes["k8s.cronjob.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.cronjob.name"]) where resource.attributes["k8s.cronjob.name"] != nil

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  otlp/self-metrics:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:14317

service:
  extensions:
  - health_check
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - transform/collision
      - transform/aco-gke
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    logs:
      encoding: json
    metrics:
      readers:
      - periodic:
          exporter:
            otlp:
              protocol: grpc
              endpoint: ${env:MY_POD_IP}:14317

Exportateurs

La configuration du collecteur inclut les exportateurs suivants:

L'exportateur googlecloud, pour les journaux et les traces Cet exportateur est configuré avec un nom de journal par défaut.
Exportateur googlemanagedprometheus pour les métriques. Cet exportateur ne nécessite aucune configuration, mais des options de configuration sont disponibles. Pour en savoir plus sur les options de configuration de l'exportateur googlemanagedprometheus, consultez la section Premiers pas avec le collecteur OpenTelemetry dans la documentation Google Cloud Managed Service pour Prometheus.

Processeurs

La configuration du collecteur inclut les processeurs suivants:

batch : configuré pour regrouper des requêtes de télémétrie avec le nombre maximal d' Google Cloud entrées par requête, ou avec l'intervalle minimal de Google Cloud cinq secondes (selon ce qui survient en premier).
memory_limiter : limite l'utilisation de la mémoire du collecteur pour éviter les plantages dus à la mémoire saturée en supprimant des points de données lorsque la limite est dépassée.
resourcedetection : détecte automatiquement les étiquettes de ressources Google Cloud , telles que project_id et cluster_name.
k8sattributes : mappe automatiquement les attributs de ressource Kubernetes aux étiquettes de télémétrie.
transform : renomme les étiquettes de métriques qui entrent en conflit avec les étiquettes des ressources surveillées. Google Cloud

Récepteurs

La configuration du collecteur n'inclut que le récepteur otlp. Pour en savoir plus sur l'instrumentation de vos applications afin d'envoyer des traces et des métriques OTLP au point de terminaison OTLP du collecteur, consultez la section Choisir une approche d'instrumentation.

Composants disponibles

Le collecteur OpenTelemetry conçu par Google contient les composants dont la plupart des utilisateurs auront besoin pour bénéficier d'une expérience enrichie dans Google Cloud Observability. Pour obtenir la liste complète des composants disponibles, consultez la section Composants dans le dépôt opentelemetry-operations-collector.

Pour demander des modifications ou des ajouts aux composants disponibles, envoyez une demande de fonctionnalité dans le dépôt opentelemetry-operations-collector.

Générer des données de télémétrie

Cette section décrit comment déployer un exemple d'application, puis faire pointer cette application vers le point de terminaison OTLP du collecteur et afficher la télémétrie dansGoogle Cloud. L'application exemple est un petit générateur qui exporte des traces, des journaux et des métriques vers le collecteur.

Si vous disposez déjà d'une application instrumentée avec un SDK OpenTelemetry, vous pouvez plutôt la faire pointer vers le point de terminaison du collecteur.

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

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/otlp-k8s-ingest/main/sample/app.yaml

Pour faire pointer des applications existantes qui utilisent le SDK OpenTelemetry vers le point de terminaison du collecteur, définissez la variable d'environnement OTEL_EXPORTER_OTLP_ENDPOINT sur http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Après quelques minutes, la télémétrie générée par l'application commence à circuler à travers le collecteur vers la console Google Cloud pour chaque signal.

Afficher la télémétrie

Le collecteur OpenTelemetry conçu par Google envoie les métriques, les journaux et les traces de vos applications instrumentées à Google Cloud Observability. Le collecteur envoie également des métriques d'auto-observation. Les sections suivantes expliquent comment afficher cette télémétrie.

Afficher vos métriques

Le collecteur OpenTelemetry conçu par Google collecte des métriques Prometheus que vous pouvez afficher à l'aide de l'explorateur de métriques. Les métriques collectées dépendent de l'instrumentation de l'application, bien que le collecteur Google écrive également certaines métriques automatiques.

Pour afficher les métriques collectées par le collecteur OpenTelemetry conçu par Google, procédez comme suit :

Dans la console Google Cloud, accédez à la page Explorateur de métriques :
Accéder à l'explorateur de métriques

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
Dans la barre d'outils de la console Google Cloud, sélectionnez votre projet Google Cloud. Pour les configurations App Hub, sélectionnez le projet hôte App Hub ou le projet de gestion du dossier compatible avec les applications.
Dans l'élément Métrique, développez le menu Sélectionner une métrique, saisissez Prometheus Target dans la barre de filtre, puis utilisez les sous-menus pour sélectionner un type de ressource et des métriques spécifiques :
1. Dans le menu Ressources actives, sélectionnez Cible Prometheus.
2. Pour sélectionner une métrique, utilisez les menus Catégories de métriques actives et Métriques actives. Les métriques collectées par le collecteur OpenTelemetry conçu par Google portent le préfixe prometheus.googleapis.com.
3. Cliquez sur Appliquer.
Configurez le mode d'affichage des données.
Lorsque les mesures d'une métrique sont cumulatives, l'explorateur de métriques normalise automatiquement les données mesurées par période d'alignement, ce qui permet d'afficher un taux dans le graphique. Pour en savoir plus, consultez la section Genres, types et conversions.

Lorsque des valeurs entières ou doubles sont mesurées, par exemple avec les métriques counter, l'explorateur de métriques additionne automatiquement toutes les séries temporelles. Pour modifier ce comportement, définissez le premier menu de l'entrée Agrégation sur Aucun.

Pour plus d'informations sur la configuration d'un graphique, consultez la page Sélectionner des métriques lors de l'utilisation de l'explorateur de métriques.

Afficher vos traces

Pour afficher vos données de trace, procédez comme suit:

Dans la console Google Cloud, accédez à la page Explorateur Trace.
Accéder à Explorateur Trace

Vous pouvez également accéder à cette page à l'aide de la barre de recherche.
Dans la barre d'outils de la console Google Cloud, sélectionnez votre projet Google Cloud. Pour les configurations App Hub, sélectionnez le projet hôte App Hub ou le projet de gestion du dossier compatible avec les applications.
Dans la section du tableau de la page, sélectionnez une ligne.
Dans le graphique de Gantt du panneau Détails des traces, sélectionnez un segment.

Un panneau s'ouvre et affiche des informations sur la requête tracée. Ces informations incluent la méthode, le code d'état, le nombre d'octets et le user-agent de l'appelant.
Pour afficher les journaux associés à cette trace, sélectionnez l'onglet Logs & Events (Journaux et événements).

Cet onglet affiche les journaux individuels. Pour afficher les détails de l'entrée de journal, développez-la. Vous pouvez également cliquer sur Afficher les journaux et afficher le journal à l'aide de l'explorateur de journaux.

Pour en savoir plus sur l'utilisation de l'explorateur Cloud Trace, consultez la page Rechercher et explorer des traces.

Afficher les journaux

L'explorateur de journaux vous permet d'inspecter vos journaux et d'afficher les traces associées, lorsqu'elles existent.

Dans la console Google Cloud, accédez à la page Explorateur de journaux :
Accéder à l'explorateur de journaux

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Logging.
Recherchez une entrée de journal dans votre application instrumentée. Pour afficher les détails, développez l'entrée de journal.
Cliquez sur Traces sur une entrée de journal contenant un message de trace, puis sélectionnez Afficher les détails des traces.

Un panneau Trace details (Informations sur la trace) s'ouvre et affiche la trace sélectionnée.

Pour en savoir plus sur l'utilisation de l'explorateur de journaux, consultez la page Afficher les journaux à l'aide de l'explorateur de journaux.

Observer et déboguer le collecteur

Le collecteur OpenTelemetry conçu par Google fournit automatiquement des métriques d'auto-observation pour vous aider à surveiller ses performances et à assurer la disponibilité continue du pipeline d'ingestion OTLP.

Pour surveiller le collecteur, installez l'exemple de tableau de bord pour le collecteur. Ce tableau de bord fournit des insights brefs sur plusieurs métriques du collecteur, y compris le temps d'activité, l'utilisation de la mémoire et les appels d'API vers Google Cloud Observability.

Pour installer le tableau de bord, procédez comme suit :

Dans la console Google Cloud, accédez à la page Tableaux de bord .
Accéder à la page Tableaux de bord

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.
Cliquez sur Modèles de tableaux de bord.
Recherchez le tableau de bord Collecteur OpenTelemetry.
Facultatif: Pour prévisualiser le tableau de bord, sélectionnez-le.
Cliquez sur Ajouter le tableau de bord à votre liste, puis remplissez la boîte de dialogue.

La boîte de dialogue vous permet de sélectionner le nom du tableau de bord et d'y ajouter des libellés.

Pour en savoir plus sur l'installation de tableaux de bord, consultez Installer un modèle de tableau de bord.