SupportConsoleDéveloppeursCommencer un essaiContact

8.4. Traçage

8.4.1. Traçage des demandes

Le traçage distribué enregistre le cheminement d'une requête à travers les différents services qui composent une application. Il est utilisé pour relier les informations relatives à différentes unités de travail, afin de comprendre l'ensemble de la chaîne d'événements d'une transaction distribuée. Les unités de travail peuvent être exécutées dans différents processus ou hôtes.

8.4.1.1. Aperçu du traçage distribué

En tant que propriétaire de service, vous pouvez utiliser le traçage distribué pour instrumenter vos services afin de recueillir des informations sur votre architecture de service. Vous pouvez utiliser le traçage distribué pour la surveillance, le profilage du réseau et le dépannage de l'interaction entre les composants dans les applications modernes, cloud-natives et basées sur les microservices.

Le traçage distribué permet d'exécuter les fonctions suivantes :

  • Contrôler les transactions distribuées
  • Optimiser les performances et la latence
  • Effectuer une analyse des causes profondes

Le traçage distribué de Red Hat OpenShift se compose de deux éléments principaux :

  • Red Hat OpenShift distributed tracing platform - Ce composant est basé sur le projet open source Jaeger.
  • Red Hat OpenShift distributed tracing data collection - Ce composant est basé sur le projet open source OpenTelemetry.

Ces deux composants sont basés sur les API et l'instrumentation OpenTracing, neutres vis-à-vis des fournisseurs.

8.4.1.2. Ressources supplémentaires

8.4.2. Utiliser le traçage distribué de Red Hat OpenShift

Vous pouvez utiliser le traçage distribué Red Hat OpenShift avec OpenShift Serverless pour surveiller et dépanner les applications sans serveur.

8.4.2.1. Utiliser Red Hat OpenShift distributed tracing pour activer le traçage distribué

Le traçage distribué de Red Hat OpenShift est constitué de plusieurs composants qui fonctionnent ensemble pour collecter, stocker et afficher les données de traçage.

Conditions préalables

  • Vous avez accès à un compte OpenShift Container Platform avec un accès administrateur de cluster.
  • Vous n'avez pas encore installé OpenShift Serverless Operator, Knative Serving et Knative Eventing. Ceux-ci doivent être installés après l'installation de Red Hat OpenShift distributed tracing.
  • Vous avez installé le traçage distribué de Red Hat OpenShift en suivant la documentation OpenShift Container Platform "Installing distributed tracing".
  • Vous avez installé l'OpenShift CLI (oc).
  • Vous avez créé un projet ou avez accès à un projet avec les rôles et autorisations appropriés pour créer des applications et d'autres charges de travail dans OpenShift Container Platform.

Procédure

  1. Créer une ressource personnalisée (CR) à l'adresse OpenTelemetryCollector:

    Exemple d'OpenTelemetryCollector CR

    apiVersion: opentelemetry.io/v1alpha1
kind: OpenTelemetryCollector
metadata:
  name: cluster-collector
  namespace: <namespace>
spec:
  mode: deployment
  config: |
    receivers:
      zipkin:
    processors:
    exporters:
      jaeger:
        endpoint: jaeger-all-in-one-inmemory-collector-headless.tracing-system.svc:14250
        tls:
          ca_file: "/var/run/secrets/kubernetes.io/serviceaccount/service-ca.crt"
      logging:
    service:
      pipelines:
        traces:
          receivers: [zipkin]
          processors: []
          exporters: [jaeger, logging]

  2. Vérifiez que vous avez deux pods en cours d'exécution dans l'espace de noms où le traçage distribué de Red Hat OpenShift est installé : 

    $ oc get pods -n <namespace>

    Exemple de sortie

    NAME                                          READY   STATUS    RESTARTS   AGE
cluster-collector-collector-85c766b5c-b5g99   1/1     Running   0          5m56s
jaeger-all-in-one-inmemory-ccbc9df4b-ndkl5    2/2     Running   0          15m

  3. Vérifiez que les services sans tête suivants ont été créés : 

    oc get svc -n <namespace> | grep headless

    Exemple de sortie

    cluster-collector-collector-headless            ClusterIP   None             <none>        9411/TCP                                 7m28s
jaeger-all-in-one-inmemory-collector-headless   ClusterIP   None             <none>        9411/TCP,14250/TCP,14267/TCP,14268/TCP   16m

    Ces services sont utilisés pour configurer Jaeger, Knative Serving et Knative Eventing. Le nom du service Jaeger peut varier.

  4. Installez l'OpenShift Serverless Operator en suivant la documentation "Installing the OpenShift Serverless Operator".

  5. Installez Knative Serving en créant le CR KnativeServing suivant :

    Exemple KnativeServing CR

    apiVersion: operator.knative.dev/v1beta1
kind: KnativeServing
metadata:
    name: knative-serving
    namespace: knative-serving
spec:
  config:
    tracing:
      backend: "zipkin"
      zipkin-endpoint: "http://cluster-collector-collector-headless.tracing-system.svc:9411/api/v2/spans"
      debug: "false"
      sample-rate: "0.1" 1

    1
    Le site sample-rate définit la probabilité d'échantillonnage. L'utilisation de sample-rate: "0.1" signifie qu'une trace sur dix est échantillonnée.

  6. Installez Knative Eventing en créant le CR KnativeEventing suivant :

    Exemple KnativeEventing CR

    apiVersion: operator.knative.dev/v1beta1
kind: KnativeEventing
metadata:
    name: knative-eventing
    namespace: knative-eventing
spec:
  config:
    tracing:
      backend: "zipkin"
      zipkin-endpoint: "http://cluster-collector-collector-headless.tracing-system.svc:9411/api/v2/spans"
      debug: "false"
      sample-rate: "0.1" 1

    1
    Le site sample-rate définit la probabilité d'échantillonnage. L'utilisation de sample-rate: "0.1" signifie qu'une trace sur dix est échantillonnée.

  7. Créer un service Knative :

    Exemple de service

    apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: helloworld-go
spec:
  template:
    metadata:
      labels:
        app: helloworld-go
      annotations:
        autoscaling.knative.dev/minScale: "1"
        autoscaling.knative.dev/target: "1"
    spec:
      containers:
      - image: quay.io/openshift-knative/helloworld:v1.2
        imagePullPolicy: Always
        resources:
          requests:
            cpu: "200m"
        env:
        - name: TARGET
          value: "Go Sample v1"

  8. Formulez des demandes auprès du service :

    Exemple de demande HTTPS

    $ curl https://helloworld-go.example.com

  9. Obtenir l'URL de la console web Jaeger :

    Example command

    $ oc get route jaeger-all-in-one-inmemory  -o jsonpath='{.spec.host}' -n <namespace>

    Vous pouvez maintenant examiner les traces en utilisant la console Jaeger.

8.4.3. Utilisation du traçage distribué de Jaeger

Si vous ne souhaitez pas installer tous les composants de Red Hat OpenShift distributed tracing, vous pouvez toujours utiliser le traçage distribué sur OpenShift Container Platform avec OpenShift Serverless.

8.4.3.1. Configurer Jaeger pour activer le traçage distribué

Pour activer le traçage distribué à l'aide de Jaeger, vous devez installer et configurer Jaeger en tant qu'intégration autonome.

Conditions préalables

  • Vous avez accès à un compte OpenShift Container Platform avec un accès administrateur de cluster.
  • Vous avez installé OpenShift Serverless Operator, Knative Serving et Knative Eventing.
  • Vous avez installé la plateforme de traçage distribuée Red Hat OpenShift Operator.
  • Vous avez installé l'OpenShift CLI (oc).
  • Vous avez créé un projet ou avez accès à un projet avec les rôles et autorisations appropriés pour créer des applications et d'autres charges de travail dans OpenShift Container Platform.

Procédure

  1. Créez et appliquez une ressource personnalisée (CR) Jaeger qui contient les éléments suivants :

    Jaeger CR

    apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: jaeger
  namespace: default

  2. Activer le traçage pour Knative Serving, en éditant le CR KnativeServing et en ajoutant une configuration YAML pour le traçage :

    Exemple de traçage YAML pour le service

    apiVersion: operator.knative.dev/v1beta1
kind: KnativeServing
metadata:
  name: knative-serving
  namespace: knative-serving
spec:
  config:
    tracing:
      sample-rate: "0.1" 1
      backend: zipkin 2
      zipkin-endpoint: "http://jaeger-collector.default.svc.cluster.local:9411/api/v2/spans" 3
      debug: "false" 4

    1
    Le site sample-rate définit la probabilité d'échantillonnage. L'utilisation de sample-rate: "0.1" signifie qu'une trace sur dix est échantillonnée.
    2
    backend doit être réglé sur zipkin.
    3
    L'adresse zipkin-endpoint doit pointer vers le point de terminaison de votre service jaeger-collector. Pour obtenir ce point de terminaison, remplacez l'espace de noms dans lequel la CR Jaeger est appliquée.
    4
    Le mode débogage doit être défini sur false. L'activation du mode débogage en définissant debug: "true" permet d'envoyer toutes les travées au serveur, en contournant l'échantillonnage.

  3. Activez le traçage pour Knative Eventing en modifiant le CR KnativeEventing:

    Exemple de traçage YAML pour l'événementiel

    apiVersion: operator.knative.dev/v1beta1
kind: KnativeEventing
metadata:
  name: knative-eventing
  namespace: knative-eventing
spec:
  config:
    tracing:
      sample-rate: "0.1" 1
      backend: zipkin 2
      zipkin-endpoint: "http://jaeger-collector.default.svc.cluster.local:9411/api/v2/spans" 3
      debug: "false" 4

    1
    Le site sample-rate définit la probabilité d'échantillonnage. L'utilisation de sample-rate: "0.1" signifie qu'une trace sur dix est échantillonnée.
    2
    Définir backend à zipkin.
    3
    Dirigez le site zipkin-endpoint vers le point d'accès à votre service jaeger-collector. Pour obtenir ce point de terminaison, remplacez l'espace de noms dans lequel la CR Jaeger est appliquée.
    4
    Le mode débogage doit être défini sur false. L'activation du mode débogage en définissant debug: "true" permet d'envoyer toutes les travées au serveur, en contournant l'échantillonnage.

Vérification

Vous pouvez accéder à la console web Jaeger pour voir les données de traçage, en utilisant la route jaeger.

  1. Obtenez le nom d'hôte de la route jaeger en entrant la commande suivante : 

    $ oc get route jaeger -n default

    Exemple de sortie

    NAME     HOST/PORT                         PATH   SERVICES       PORT    TERMINATION   WILDCARD
jaeger   jaeger-default.apps.example.com          jaeger-query   <all>   reencrypt     None

  2. Ouvrez l'adresse du point de terminaison dans votre navigateur pour afficher la console.
Red Hat logoGithubRedditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez leBlog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

© 2024 Red Hat, Inc.