Tutoriel : Activer le tracing pour une application Java avec le contrôleur d'admission

Docs > APM > Guides de tracing > Tutoriel : Activer le tracing pour une application Java avec le contrôleur d'admission

Présentation

Ce tutoriel décrit les étapes à suivre pour activer le tracing d’une application Java à l’aide du contrôleur d’admission Datadog.

Pour les autres scénarios, y compris lorsque l’application est sur un host, dans un conteneur, sur une infrastructure cloud, ou encore pour les applications écrites dans d’autres langages, consultez les autres tutoriels relatifs à l’activation du tracing.

Reportez-vous à la section Tracer des applications Java pour consulter la documentation complète relative à la configuration du tracing pour Java.

Prérequis

Un compte Datadog et une clé d’API de l’organisation
Git
Docker
Curl
Kubernetes v1.14+

Installer l’exemple d’application

Pour illustrer la procédure à suivre pour instrumenter votre application avec le contrôleur d’admission Datadog, ce tutoriel se base sur une application Java conçue avec Spring. Le code de cette application se trouve sur le référentiel GitHub springblog.

Pour commencer, dupliquez le référentiel :

git clone https://github.com/DataDog/springblog.git

Ce référentiel contient une application Java dotée de plusieurs services, préconfigurée pour être exécutée dans Docker et Kubernetes. Il s’agit d’une application Spring basique reposant sur REST.

Lancer et exécuter l’exemple d’application

Basculez sur le sous-dossier /k8s dans le référentiel springblog :
```
cd springblog/k8s/
```
Déployez le workload avec le fichier depl.yaml :
```
kubectl apply -f ./depl.yaml
```

Vérifiez que le workload est en cours d’exécution avec la commande suivante :

kubectl get pods

Vous devriez obtenir une sortie similaire à celle-ci :

NAME                                       READY   STATUS        RESTARTS        AGE
springback-666db7b6b8-dzv7c                1/1     Terminating   0               2m41s
springfront-797b78d6db-p5c84               1/1     Terminating   0               2m41s

Le service est désormais lancé et effectue une écoute sur le port 8080. Il expose un endpoint /upstream.

Exécutez la commande curl suivante pour vérifier si des communications sont détectées :

curl localhost:8080/upstream
Quote{type='success', values=Values{id=6, quote='Alea jacta est'}}

Pour arrêter l’application, afin de pouvoir activer son tracing, exécutez la commande suivante à partir du répertoire springblog/k8s :
```
kubectl delete -f ./depl-with-lib-inj.yaml
```

Instrumenter votre application avec le contrôleur d’admission Datadog

Maintenant que votre application fonctionne correctement, instrumentez-la à l’aide du contrôleur d’admission Datadog. Pour des environnements conteneurisés, il convient de suivre les étapes ci-dessous :

Installez l’Agent de cluster Datadog.
Ajoutez des tags de service unifié dans la définition du pod.
Annotez votre pod pour l’injection de bibliothèque.
Ajoutez des étiquettes à votre pod pour indiquer au contrôleur d’admission Datadog qu’il doit muter le pod.

Il n’est pas nécessaire d’ajouter la bibliothèque de tracing : en effet, celle-ci est automatiquement injectée. Vous n’avez pas besoin, pour l’instant, de redéployer votre application. Il vous faut tout d’abord ajouter des variables Datadog et redéployer une nouvelle image ou version de votre application.

Depuis le sous-dossier k8s, utilisez la commande suivante pour installer l’Agent de cluster Datadog, en prenant soin de spécifier le fichier de configuration values-with-lib-inj.yaml et votre clé d’API Datadog :
```
helm install datadog-agent -f values-with-lib-inj.yaml --set datadog.site='datadoghq.com' --set datadog.apiKey=$DD_API_KEY datadog/datadog
```
Pour obtenir plus de détails sur cette étape, consultez l'onglet Helm de la section Installer l'Agent Datadog sur Kubernetes.

Pour vérifier si l’Agent de cluster Datadog est en cours d’exécution, utilisez la commande suivante :

kubectl get pods

Vous devriez obtenir une sortie similaire à celle-ci :

NAME                                                READY   STATUS    RESTARTS  AGE
datadog-agent-4s8rb                                 3/3     Running   0         30s
datadog-agent-cluster-agent-5666cffc44-d8qxk        1/1     Running   0         30s
datadog-agent-kube-state-metrics-86f46b8484-mlqp7   1/1     Running   0         30s

Ajoutez le bloc suivant au fichier depl.yaml pour ajouter des tags de service unifié :

labels:
  tags.datadoghq.com/env: "dev"
  tags.datadoghq.com/service: "springfront"
  tags.datadoghq.com/version: "12"

Configurez le contrôleur d’admission Datadog de façon à injecter une bibliothèque de tracing Java dans le conteneur de l’application. Pour ce faire, ajoutez l’annotation suivante au pod :

annotations:
  admission.datadoghq.com/java-lib.version: "latest"

Cette annotation spécifie la dernière version de la bibliothèque de tracing Java. Vous pouvez également indiquer une version de la bibliothèque spécifique, par exemple "v1.5.0".

La version finale de la définition du pod devrait ressembler à l’extrait suivant. Vous pouvez également vous rendre sur le référentiel de l’exemple pour consulter le fichier YAML complet. Les instructions ajoutées pour instrumenter l’application sont mises en évidence :

apiVersion: apps/v1
kind: Deployment
metadata:
name: springfront
labels:
    tags.datadoghq.com/env: "dev"
    tags.datadoghq.com/service: "springfront"
    tags.datadoghq.com/version: "12"
spec:
replicas: 1
selector:
    matchLabels:
    name: springfront
minReadySeconds: 15
strategy:
    type: RollingUpdate
    rollingUpdate:
    maxUnavailable: 1
    maxSurge: 1
template:
    metadata:
    labels:
        name: springfront
        tags.datadoghq.com/env: "dev"
        tags.datadoghq.com/service: "springfront"
        tags.datadoghq.com/version: "12"
    annotations:
        admission.datadoghq.com/java-lib.version: "latest"

Exécutez l’exemple d’application à l’aide de la commande suivante :
```
kubectl apply -f depl-with-lib-inj.yaml
```

Exécutez la commande suivante pour vérifier que l’application et l’Agent sont en cours d’exécution :

kubectl get pods

Vous devriez obtenir une sortie similaire à celle-ci :

NAME                                                READY   STATUS    RESTARTS   AGE
datadog-agent-4s8rb                                 3/3     Running   0          28m
datadog-agent-cluster-agent-5666cffc44-d8qxk        1/1     Running   0          28m
datadog-agent-kube-state-metrics-86f46b8484-mlqp7   1/1     Running   0          28m
springback-666db7b6b8-sb4tp                         1/1     Running   0          27m
springfront-797b78d6db-mppbg                        1/1     Running   0          27m

Exécutez la commande suivante pour afficher les détails du pod :

kubectl describe pod springfront

Vous devriez obtenir une sortie similaire à celle-ci :

Events:
Type    Reason     Age   From               Message
----    ------     ----  ----               -------
Normal  Scheduled  32s   default-scheduler  Successfully assigned default/springfront-797b78d6db-jqjdl to docker-desktop
Normal  Pulling    31s   kubelet            Pulling image "gcr.io/datadoghq/dd-lib-java-init:latest"
Normal  Pulled     25s   kubelet            Successfully pulled image "gcr.io/datadoghq/dd-lib-java-init:latest" in 5.656167878s
Normal  Created    25s   kubelet            Created container datadog-lib-java-init
Normal  Started    25s   kubelet            Started container datadog-lib-java-init
Normal  Pulling    25s   kubelet            Pulling image "pejese/springfront:v2"
Normal  Pulled     2s    kubelet            Successfully pulled image "pejese/springfront:v2" in 22.158699094s
Normal  Created    2s    kubelet            Created container springfront
Normal  Started    2s    kubelet            Started container springfront

Comme vous pouvez le voir, un init-container est ajouté à votre pod. Ce conteneur inclut les bibliothèques de tracing Java Datadog sur un montage de volume. De plus, JAVA_TOOL_OPTIONS a été modifié de façon à inclure javaagent. Les variables propres à Datadog sont également ajoutées au conteneur :

Environment:
DD_ENV:              dev
DD_VERSION:          12
DD_SERVICE:          springfront
DD_ENTITY_ID:         (v1:metadata.uid)
DD_TRACE_AGENT_URL:  unix:///var/run/datadog/apm.socket
URL:                 http://springback:8088
JAVA_TOOL_OPTIONS:    -javaagent:/datadog-lib/dd-java-agent.jar
Mounts:
/datadog-lib from datadog-auto-instrumentation (rw)
/var/run/datadog from datadog (rw)
/var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-qvmtk (ro)

Pour vérifier que la bibliothèque de tracing Datadog est injectée dans le pod, consultez les logs du pod. Exemple :

kubectl logs -f springfront-797b78d6db-jqjdl

Vous devriez obtenir une sortie similaire à celle-ci :

Defaulted container "springfront" out of: springfront, datadog-lib-java-init (init)
Picked up JAVA_TOOL_OPTIONS:  -javaagent:/datadog-lib/dd-java-agent.jar

Afficher les traces APM dans Datadog

Exécutez la commande suivante :
```
curl localhost:8080/upstream
```
Ouvrez l’interface Datadog et consultez les deux services renvoyant des données dans le catalogue des services :
Explorez les traces et consultez la Service Map associée :

Nettoyer l’environnement

Utilisez la commande suivante pour nettoyer votre environnement :

kubectl delete -f depl-with-lib-inj.yaml

L’injection de bibliothèque à l’aide du contrôleur d’admission facilite l’instrumentation de service. En effet, cela vous permet de consulter des traces APM sans avoir à modifier ni rebuild votre application. Pour en savoir plus, consultez la section Injecter des bibliothèques localement.

Dépannage

Si vous ne recevez pas les traces comme prévu, configurez le mode debugging pour le traceur Java. Consultez la rubrique Activer le mode debugging pour en savoir plus.