Déployer le collecteur OpenTelemetry sur Google Kubernetes Engine

Ce document explique comment exécuter le collecteur OpenTelemetry dans un cluster GKE pour collecter les journaux, les métriques et les traces OTLP à partir d'applications instrumentées, et exporter ces données vers Google Cloud.

Avant de commencer

L'exécution du collecteur OpenTelemetry sur GKE 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 :

      1. Accédez à la page API et services :

        Accéder à API et services

      2. Sélectionnez votre projet.

      3. Cliquez sur  Activer les API et les services.

      4. Recherchez chaque API par nom.

      5. Dans les résultats de recherche, cliquez sur l'API nommée. L'API Monitoring apparaît sous la forme "API Stackdriver Monitoring".

      6. Si l'option "API activée" ne s'affiche pas, cliquez sur le bouton Activer.

  • 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 page 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

Déployer le collecteur

Le pipeline de collecteur peut être déployé directement à partir de GitHub avec les commandes suivantes, en remplaçant PROJECT_ID par l'ID de votre projet Google Cloud :

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

Observer et déboguer le collecteur

Le collecteur OpenTelemetry fournit des métriques d'auto-observabilité prêtes à l'emploi pour vous aider à surveiller ses performances et à garantir la disponibilité continue du pipeline d'ingestion OTLP.

Pour surveiller le collecteur, installez l'exemple de tableau de bord associé. 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 :

  1. 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.

  2. Sélectionnez l'onglet Bibliothèque d'exemples.
  3. Sélectionnez la catégorie Collecteur OpenTelemetry.
  4. Sélectionnez le tableau de bord "Collecteur OpenTelemetry".
  5. Cliquez sur  Importer.

Pour en savoir plus sur le processus d'installation, consultez la page Installer des exemples de tableaux de bord.

Configurer le collecteur

Le pipeline d'ingestion OTLP autogéré inclut une configuration par défaut du collecteur OpenTelemetry, 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. Elle est également conçue pour éviter les problèmes d'ingestion courants.

Cependant, vous pouvez avoir des besoins uniques nécessitant la personnalisation de la configuration par défaut. Cette section décrit les valeurs par défaut fournies avec le pipeline et explique comment les personnaliser en fonction de vos besoins.

La configuration du collecteur par défaut se trouve sur GitHub sous le nom config/collector.yaml :

# 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.1.0 otel/opentelemetry-collector-contrib:0.106.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.106.0

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.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.1.0 otel/opentelemetry-collector-contrib:0.106.0

  # We need to add the pod IP as a resource label so the k8s attributes processor can find it.
  resource/self-metrics:
    attributes:
    - action: insert
      key: k8s.pod.ip
      value: ${env:MY_POD_IP}

  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")

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  prometheus/self-metrics:
    config:
      scrape_configs:
      - job_name: otel-self-metrics
        scrape_interval: 1m
        static_configs:
        - targets:
          - ${env:MY_POD_IP}:8888

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
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - resource/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - prometheus/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    metrics:
      address: ${env:MY_POD_IP}:8888

Exportateurs

Les exportateurs par défaut incluent l'exportateur googlecloud (pour les journaux et les traces) et l'exportateur googlemanagedprometheus (pour les métriques).

L'exportateur googlecloud est configuré avec un nom de journal par défaut. L'exportateur googlemanagedprometheus ne nécessite aucune configuration par défaut. Pour en savoir plus, consultez la section Premiers pas avec le collecteur OpenTelemetry dans la documentation Google Cloud Managed Service pour Prometheus.

Processeurs

La configuration par défaut inclut les processeurs suivants :

  • batch : configuré pour regrouper des requêtes de télémétrie avec le nombre maximal d'entrées Google Cloud par requête, ou avec l'intervalle minimal Google Cloud de cinq secondes (selon ce qui survient en premier).
  • k8sattributes : mappe automatiquement les attributs de ressource Kubernetes aux étiquettes de télémétrie.
  • memory_limiter : limite l'utilisation de la mémoire du collecteur à un niveau raisonnable pour éviter les plantages dus à la mémoire saturée en supprimant des points de données au-delà de ce niveau.
  • resourcedetection : détecte automatiquement les étiquettes de ressources Google Cloud, comme le nom du cluster et l'ID du projet.
  • transform : renomme les étiquettes de métriques qui entreraient en conflit avec les champs de ressources surveillées par Google Cloud.

Récepteurs

La configuration par défaut n'inclut que le récepteur otlp. Consultez la section Choisir une approche d'instrumentation pour obtenir des instructions détaillées sur l'instrumentation de vos applications afin de transférer des traces et des métriques OTLP au point de terminaison OTLP du collecteur.

Étapes suivantes : collecter et afficher les 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 dans Google Cloud. L'exemple d'application est un petit générateur qui exporte les traces, les journaux et les métriques vers le collecteur.

Si vous disposez déjà d'une application instrumentée avec un SDK OpenTelemetry, vous pouvez 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.