Déployer le collecteur OpenTelemetry sur Container-Optimized OS

Ce document explique comment exécuter le collecteur OpenTelemetry conçu par Google sur Container-Optimized OS 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 nécessite les ressources suivantes :

  1. Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

    8.
  8. Une machine virtuelle (VM) Container-Optimized OS. Si vous n'avez pas de VM Container-Optimized OS, suivez les instructions de la section Créer et configurer des instances.
  9. Une installation de gcloud. Pour en savoir plus sur l'installation de gcloud, consultez Installer Google Cloud CLI.

Configurer les autorisations pour le collecteur

Par défaut, les VM Container-Optimized OS utilisent le compte de service Compute Engine par défaut, PROJECT_NUMBER-compute@developer.gserviceaccount.com. Ce compte de service dispose généralement des rôles IAM (Identity and Access Management) nécessaires pour écrire la télémétrie décrite dans ce document :

Si vous configurez un compte de service personnalisé pour votre instance, consultez Gérer l'accès aux comptes de service.

Déployer le collecteur

Pour exécuter le collecteur OpenTelemetry conçu par Google, vous devez fournir un fichier de configuration pour votre VM Container-Optimized OS. Vous pouvez utiliser l'outil cloud-init pour écrire un fichier de configuration. Voici un fichier cloud-init recommandé pour utiliser le collecteur intégré à Google :

write_files:
- path: /etc/config/config.yaml
  permissions: 0644
  owner: root
  content: |
    receivers:
      # Open two OTLP servers:
      # - On port 4317, open an OTLP GRPC server
      # - On port 4318, open an OTLP HTTP server
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
      otlp:
        protocols:
          grpc:
            endpoint: localhost:4317
          http:
            cors:
              # This effectively allows any origin
              # to make requests to the HTTP server.
              allowed_origins:
              - http://*
              - https://*
            endpoint: localhost:4318

    processors:
      # The batch processor is in place to regulate both the number of requests
      # being made and the size of those requests.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
      batch:
        send_batch_max_size: 200
        send_batch_size: 200
        timeout: 5s

      # The memorylimiter will check the memory usage of the collector process.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
      memory_limiter:
        check_interval: 1s
        limit_percentage: 65
        spike_limit_percentage: 20

      # The resourcedetection processor is configured to detect GCP resources.
      # Resource attributes that represent the GCP resource the collector is
      # running on will be attached to all telemetry that goes through this
      # processor.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
      resourcedetection:
        detectors: [gcp]
        timeout: 10s

      # The resource/gcp_project_id processor sets the GCP project ID attribute on telemetry data exported via OTLP.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourceprocessor
      resource/gcp_project_id:
        attributes:
        - action: insert
          key: gcp.project_id
          value: ${GOOGLE_CLOUD_PROJECT}

      # The metricstarttime processor sets start time on delta metrics for OTLP export.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/metricstarttimeprocessor
      metricstarttime:
        strategy: subtract_initial_point

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

      # For each Prometheus unknown-typed metric, which is a gauge, create a counter that is an exact copy of this metric.
      # The GCP OTLP endpoint will add appropriate suffixes for the counter and gauge.
      transform/prometheus_unknown_types:
        error_mode: ignore
        metric_statements:
        - context: metric
          statements:
          - copy_metric(Concat([metric.name, "unknowncounter"], ":")) where metric.metadata["prometheus.type"] == "unknown" and not HasSuffix(metric.name, ":unknowncounter")
          - convert_gauge_to_sum("cumulative", true) where HasSuffix(metric.name, ":unknowncounter")
          - set(metric.name, Substring(metric.name, 0, Len(metric.name)-Len(":unknowncounter"))) where HasSuffix(metric.name, ":unknowncounter")

      transform/otlp_grpc/preserve_instrumentation_source_version:
        error_mode: ignore
        log_statements:
        - context: log
          statements:
          - set(attributes["instrumentation_source"], instrumentation_scope.name) where instrumentation_scope.name != ""
          - set(attributes["instrumentation_version"], instrumentation_scope.version) where instrumentation_scope.version != ""

      transform/otlp_grpc/copy_service_resource_labels:
        error_mode: ignore
        log_statements:
        - context: log
          statements:
          - set(attributes["service.name"], resource.attributes["service.name"]) where resource.attributes["service.name"] != nil
          - set(attributes["service.namespace"], resource.attributes["service.namespace"]) where resource.attributes["service.namespace"] != nil
          - set(attributes["service.instance.id"], resource.attributes["service.instance.id"]) where resource.attributes["service.instance.id"] != nil

    exporters:
      # The otlp_grpc exporter is used to send telemetry (logs, metrics, traces) to GCP Telemetry API using OTLP gRPC.
      #
      # Docs:
      # https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter
      otlp_grpc:
        endpoint: telemetry.googleapis.com:443
        balancer_name: pick_first
        auth:
          authenticator: googleclientauth

    extensions:
      googleclientauth:

    service:
      extensions:
      - googleclientauth
      pipelines:
        logs:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - transform/otlp_grpc/preserve_instrumentation_source_version
          - transform/otlp_grpc/copy_service_resource_labels
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
        metrics/otlp:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - transform/collision
          - transform/prometheus_unknown_types
          - metricstarttime
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
        traces:
          receivers:
          - otlp
          processors:
          - resourcedetection
          - resource/gcp_project_id
          - memory_limiter
          - batch
          exporters:
          - otlp_grpc
      # Internal telemetry for the collector supports both push and pull-based telemetry data transmission.
      # Leveraging the pre-configured OTLP receiver eliminates the need for an additional port.
      #
      # Docs:
      # https://opentelemetry.io/docs/collector/internal-telemetry/
      telemetry:
        metrics:
          readers:
            - periodic:
                exporter:
                  otlp:
                    protocol: grpc
                    endpoint: http://localhost:4317
                    insecure: true

Nous vous recommandons de créer un réseau Docker bridge pour faciliter la communication entre le conteneur Collector et tout autre conteneur du système qui enverra des données de télémétrie. Pour créer le réseau, exécutez la commande suivante :

docker network create -d bridge otel

Exécutez le conteneur Collector avec la commande suivante :

docker run -d \
    --network otel \
    --name opentelemetry-collector \
    -v /etc/config:/etc/config \
    us-docker.pkg.dev/cloud-ops-agents-artifacts/google-cloud-opentelemetry-collector/otelcol-google:0.160.0 \
    --config=/etc/config/config.yaml

La commande précédente effectue les opérations suivantes :

  • Exécute le conteneur du collecteur en arrière-plan.
  • Associe le conteneur Collector au réseau pont otel créé précédemment. D'autres conteneurs peuvent être connectés au pont pour envoyer des données de télémétrie.
  • Monte votre fichier de configuration sur le conteneur afin que le fichier soit accessible pour configurer le collecteur.

Configurer le collecteur

Nous fournissons une configuration du collecteur OpenTelemetry que vous pouvez utiliser avec le collecteur conçu par Google. Cette configuration est conçue pour fournir de grands volumes de métriques, de journaux et de traces OTLP. 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 composants clés tels que les exportateurs, les processeurs, les récepteurs et les autres composants disponibles.

Configuration du collecteur fournie

Vous trouverez la configuration du collecteur dans le répertoire google-built-opentelemetry-collector du dépôt opentelemetry-operations-collector :

receivers:
  # Open two OTLP servers:
  # - On port 4317, open an OTLP GRPC server
  # - On port 4318, open an OTLP HTTP server
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
  otlp:
    protocols:
      grpc:
        endpoint: localhost:4317
      http:
        cors:
          # This effectively allows any origin
          # to make requests to the HTTP server.
          allowed_origins:
          - http://*
          - https://*
        endpoint: localhost:4318

processors:
  # The batch processor is in place to regulate both the number of requests
  # being made and the size of those requests.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  # The memorylimiter will check the memory usage of the collector process.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/memorylimiterprocessor
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  # The resourcedetection processor is configured to detect GCP resources.
  # Resource attributes that represent the GCP resource the collector is
  # running on will be attached to all telemetry that goes through this
  # processor.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#gcp-metadata
  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  # The resource/gcp_project_id processor sets the GCP project ID attribute on telemetry data exported via OTLP.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourceprocessor
  resource/gcp_project_id:
    attributes:
    - action: insert
      key: gcp.project_id
      value: ${GOOGLE_CLOUD_PROJECT}

  # The metricstarttime processor sets start time on delta metrics for OTLP export.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/metricstarttimeprocessor
  metricstarttime:
    strategy: subtract_initial_point

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

  # For each Prometheus unknown-typed metric, which is a gauge, create a counter that is an exact copy of this metric.
  # The GCP OTLP endpoint will add appropriate suffixes for the counter and gauge.
  transform/prometheus_unknown_types:
    error_mode: ignore
    metric_statements:
    - context: metric
      statements:
      - copy_metric(Concat([metric.name, "unknowncounter"], ":")) where metric.metadata["prometheus.type"] == "unknown" and not HasSuffix(metric.name, ":unknowncounter")
      - convert_gauge_to_sum("cumulative", true) where HasSuffix(metric.name, ":unknowncounter")
      - set(metric.name, Substring(metric.name, 0, Len(metric.name)-Len(":unknowncounter"))) where HasSuffix(metric.name, ":unknowncounter")

  transform/otlp_grpc/preserve_instrumentation_source_version:
    error_mode: ignore
    log_statements:
    - context: log
      statements:
      - set(attributes["instrumentation_source"], instrumentation_scope.name) where instrumentation_scope.name != ""
      - set(attributes["instrumentation_version"], instrumentation_scope.version) where instrumentation_scope.version != ""

  transform/otlp_grpc/copy_service_resource_labels:
    error_mode: ignore
    log_statements:
    - context: log
      statements:
      - set(attributes["service.name"], resource.attributes["service.name"]) where resource.attributes["service.name"] != nil
      - set(attributes["service.namespace"], resource.attributes["service.namespace"]) where resource.attributes["service.namespace"] != nil
      - set(attributes["service.instance.id"], resource.attributes["service.instance.id"]) where resource.attributes["service.instance.id"] != nil

exporters:
  # The otlp_grpc exporter is used to send telemetry (logs, metrics, traces) to GCP Telemetry API using OTLP gRPC.
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlpexporter
  otlp_grpc:
    endpoint: telemetry.googleapis.com:443
    balancer_name: pick_first
    auth:
      authenticator: googleclientauth

extensions:
  # Opens an endpoint on 13133 that can be used to check the
  # status of the collector. Since this does not configure the
  # `path` config value, the endpoint will default to `/`.
  #
  # When running on Cloud Run, this extension is required and not optional.
  # In other environments it is recommended but may not be required for operation
  # (i.e. in Container-Optimized OS or other GCE environments).
  #
  # Docs:
  # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/healthcheckextension
  health_check:
    endpoint: 0.0.0.0:13133
  googleclientauth:

service:
  extensions:
  - health_check
  - googleclientauth
  pipelines:
    logs:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - transform/otlp_grpc/preserve_instrumentation_source_version
      - transform/otlp_grpc/copy_service_resource_labels
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
    metrics/otlp:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - transform/collision
      - transform/prometheus_unknown_types
      - metricstarttime
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
    traces:
      receivers:
      - otlp
      processors:
      - resourcedetection
      - resource/gcp_project_id
      - memory_limiter
      - batch
      exporters:
      - otlp_grpc
  # Internal telemetry for the collector supports both push and pull-based telemetry data transmission.
  # Leveraging the pre-configured OTLP receiver eliminates the need for an additional port.
  #
  # Docs:
  # https://opentelemetry.io/docs/collector/internal-telemetry/
  telemetry:
    metrics:
      readers:
        - periodic:
            exporter:
              otlp:
                protocol: grpc
                endpoint: http://localhost:4317
                insecure: true

Exportateurs

La configuration du collecteur utilise les éléments suivants :

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'entrées Google Cloud par requête, ou avec l'intervalle minimal Google Cloud de 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 , comme project_id.

Récepteurs

La configuration du collecteur n'inclut que le récepteur otlp. Pour savoir comment instrumenter vos applications afin d'envoyer des traces et des métriques OTLP au point de terminaison OTLP du collecteur, consultez 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 profiter d'une expérience riche dans Google Cloud Observability. Pour obtenir la liste complète des composants disponibles, consultez Composants dans le dépôt opentelemetry-operations-collector.

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

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

Vous pouvez tester votre configuration à l'aide de l'outil telemetrygen Open Source. Le projet OpenTelemetry fournit un conteneur dans le registre de conteneurs GitHub.

Avant d'exécuter les commandes suivantes, remplacez les espaces réservés ci-dessous si vous avez modifié les valeurs par défaut utilisées dans les commandes Docker de la section Déployer le collecteur :

  • otel : nom que vous avez spécifié lors de la création du réseau Docker bridge.
  • opentelemetry-collector : nom que vous avez spécifié lors de l'exécution du conteneur.

Générer des journaux

Pour générer des journaux à l'aide de l'outil telemetrygen, exécutez la commande suivante :

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  logs --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Générer des métriques

Pour générer des métriques à l'aide de l'outil telemetrygen, exécutez la commande suivante :

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  metrics --otlp-insecure --rate=0.1 --duration=5m \
  --otlp-endpoint=opentelemetry-collector:4317

Générer des traces

Pour générer des traces à l'aide de l'outil telemetrygen, exécutez la commande suivante :

docker run \
  --net=otel \
  ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:v0.105.0 \
  traces --otlp-insecure --rate=3 --duration=5m \
  --otlp-endpoint=opentelemetry-collector: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-observabilité. Les sections suivantes décrivent comment afficher cette télémétrie.

Afficher vos métriques

Le collecteur OpenTelemetry intégré à Google collecte les 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 conçu par Google écrive également certaines métriques propres.

Pour afficher les métriques collectées par le collecteur OpenTelemetry intégré à Google, procédez comme suit :

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

  2. 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.
  3. 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 intégré à Google ont le préfixe prometheus.googleapis.com.
    3. Cliquez sur Appliquer.

  4. Pour ajouter des filtres qui suppriment des séries temporelles des résultats de la requête, utilisez l'élément Filtre.

  5. 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 Sélectionner des métriques lorsque vous utilisez l'explorateur de métriques.

Afficher vos traces

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

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

  2. 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.
  3. Dans la section du tableau de la page, sélectionnez une ligne.

  4. Dans le graphique de Gantt du panneau Détails des traces, sélectionnez un segment.

    Un panneau contenant des informations sur la requête tracée s'affiche. Ces informations incluent la méthode, le code d'état, le nombre d'octets et le user-agent de l'appelant.

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

  1. Dans la console Google Cloud , accédez à la pageExplorateur 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.

  2. Recherchez une entrée de journal dans votre application instrumentée. Pour afficher les détails, développez l'entrée de journal.

  3. 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 Afficher les journaux à l'aide de l'explorateur de journaux.

Observer et déboguer le collecteur

Le collecteur OpenTelemetry intégré à Google fournit automatiquement des métriques d'auto-observabilité 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 correspondant. 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. Cliquez sur Modèles de tableau de bord.
  3. Recherchez le tableau de bord Collecteur OpenTelemetry.
  4. Facultatif : Pour prévisualiser le tableau de bord, sélectionnez-le.

  5. Cliquez sur Ajouter un 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 des tableaux de bord, consultez Installer un modèle de tableau de bord.