Pour déployer l'agent Java APM, procédez comme suit :

1. Avant de continuer, vérifiez que vous avez terminé les prérequis et provisionné l'agent Java APM.
   Remarque
   
   Lors du provisionnement de l'agent Java APM, il est recommandé de le provisionner à l'emplacement de votre ordinateur local, puis de le copier vers une image Docker.
2. Modifiez Dockerfile pour copier l'agent Java APM vers une image Docker :

   COPY <DESTINATION_DIRECTORY>/oracle-apm-agent <Docker_Image_Directory>/oracle-apm-agent/

   <DESTINATION_DIRECTORY> désigne l'emplacement où vous avez provisionné l'agent Java APM sur l'ordinateur local et <Docker_Image_Directory> le répertoire de l'image Docker vers lequel vous copiez l'agent Java APM. <Docker_Image_Directory> peut également désigner le répertoire de destination du serveur d'applications dans Docker, par exemple $DOMAIN_HOME, si vous utilisez Oracle WebLogic Server.

3. Ajoutez l'option -javaagent suivante au script de démarrage du serveur d'applications :

   java -javaagent:<Docker_Image_Directory>/oracle-apm-agent/bootstrap/ApmAgent.jar -jar target/<appserver.jar>

4. Créez une image Docker à l'aide de l'agent Java APM intégré et du script de démarrage modifié, puis transmettez-la au registre.

Si vous utilisez Kubernetes pour gérer vos conteneurs Docker, mettez à jour votre configuration Kubernetes de façon à utiliser la nouvelle image Docker, puis redémarrez le pod Kubernetes.

Vous pouvez également définir des dimensions supplémentaires pour lesquelles générer des rapports à partir du pod Kubernetes à l'aide de l'API Downward, en copiant les paramètres d'environnement et de volume suivants dans la spécification de déploiement (fichier yaml) du pod Kubernetes. Reportez-vous à la section sur l'API Downward dans la documentation Kubernetes pour obtenir plus d'information.

Paramètres d'environnement

spec:
  containers:
  - name: <container-name>
    image: image: <your-registry>/<your-docker-image>:latest
    env:
      - name: APM_ATTRIBUTES_K8S_POD_NAME
        valueFrom:
          fieldRef:
            fieldPath: metadata.name
      - name: APM_ATTRIBUTES_K8S_NAMESPACE_NAME
        valueFrom:
          fieldRef:
            fieldPath: metadata.namespace
      - name: APM_ATTRIBUTES_K8S_NODE_NAME
        valueFrom:
          fieldRef:
            fieldPath: spec.nodeName

Paramètres de volume

spec:
  containers:
  - name: <container-name>
    image: image: <your-registry>/<your-docker-image>:latest
    volumeMounts:
      - name: apm-attributes-k8s
        mountPath: /etc/apm-attributes-k8s
    volumes:
      - name: apm-attributes-k8s
        downwardAPI:
         items:
           - path: "labels"
             fieldRef:
               fieldPath: metadata.labels
           - path: "annotations"
             fieldRef:
               fieldPath: metadata.annotations

Prérequis : installez l'opérateur OpenTelemetry dans le cluster Kubernetes.

Trois options sont disponibles : Operator release manifest, Operator helm chart ou Operator Hub.

Dans la plupart des cas, un cert-manager doit être installé. Si l'option de graphique en barre est utilisée, vous pouvez générer un certificat auto-signé à la place.

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.2/cert-manager.yaml

Pour installer l'opérateur OpenTelemetry, exécutez la commande suivante :

kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml

Déployer l'agent Java APM

Pour déployer l'agent Java APM, procédez comme suit :

1. Créez une ressource personnalisée Kubernetes (CR).

   Pour gérer l'instrumentation automatique, l'opérateur OpenTelemetry doit recevoir des informations sur l'agent Java APM et sa configuration, ce qui est fait à l'aide de la définition de ressource personnalisée (CRD).

   Cette ressource personnalisée sera utilisée par l'opérateur pour copier l'agent dans le pod et lui ajouter la configuration requise.

   Pour créer la CR, exécutez la commande suivante :

   kubectl apply -f - <<EOF
   apiVersion: opentelemetry.io/v1alpha1
   kind: Instrumentation
   metadata:
     name: inst-apm-java
     namespace: opentelemetry-operator-system
   spec:
     java:
       image: container-registry.oracle.com/oci_observability_management/oci-apm-java-agent:1.15.0.516
       env:
         - name: OTEL_com_oracle_apm_agent_data_upload_endpoint
           value: <data-upload-endpoint>
         - name: OTEL_com_oracle_apm_agent_private_data_key
           value: <private-data-key>
   EOF

   Où :

   • <data-upload-endpoint> est l'URL d'adresse de téléchargement de données générée lors de la création du domaine APM. Pour plus d'informations, reportez-vous à Obtention de l'adresse de téléchargement de données et des clés de données.
   • <private-data-key> est la clé de données privée d'installation d'agent Java APM qui est générée lors de la création du domaine APM. Pour plus d'informations, reportez-vous à Obtention de l'adresse de téléchargement de données et des clés de données.
   Vous pouvez interroger le CR créé en exécutant la commande suivante :

   kubectl get otelinst -n opentelemetry-operator-system

   Tous les points de terminaison et variables d'environnement doivent être corrects pour que l'instrumentation automatique fonctionne correctement.
2. Ajoutez l'annotation Kubernetes.

   L'opérateur OpenTelemetry utilise l'annotation Kubernetes pour déterminer les pods à injecter automatiquement avec l'agent Java APM.

   L'annotation peut être ajoutée à un espace de noms. Dans ce cas, tous les pods de cet espace de noms seront injectés. L'annotation peut également être ajoutée à des objets PodSpec individuels, disponibles dans le cadre du déploiement, de Statefulset et d'autres ressources.

   Annotation :

   instrumentation.opentelemetry.io/inject-java: "opentelemetry-operator-system/inst-apm-java"

   Pour commencer à modifier votre espace de noms, procédez comme suit :

   • Exécutez la commande :

     kubectl edit namespace <your-namespace-name>

   • Modifiez l'espace de noms une fois l'éditeur ouvert. Par exemple, éditeur vi.
   • Ajoutez l'annotation à l'espace de noms. Gardez à l'esprit que l'indentation est très importante pour en faire un fichier YAML valide.
   Exemple :

   apiVersion: v1
   kind: Namespace
   metadata:
     labels:
       kubernetes.io/metadata.name: mynamespace
     annotations:
       instrumentation.opentelemetry.io/inject-java: "opentelemetry-operator-system/inst-apm-java"
     name: mynamespace
   spec:

3. Redémarrez le pod Kubernetes.

   Pour redémarrer le pod dans lequel vous voulez injecter automatiquement l'agent Java APM, exécutez la commande suivante :

   kubectl delete pod <your-pod-name> -n <your-namespace-name>

4. Vérifiez le pod Kubernetes.
   Pour vérifier que le pod a été injecté automatiquement avec l'agent Java APM après son redémarrage, exécutez la commande suivante :

   kubectl get pod <your-pod-name> -n <your-namespace-name> -o yaml

Vous pouvez maintenant passer à l'étape suivante : Vérifier le déploiement de l'agent Java APM.

Pour déployer l'agent Java APM sur un volume monté, procédez comme suit :

1. Vérifiez que vous avez terminé les tâches prérequises de l'agent Java APM.

   Notez l'adresse de téléchargement de données et la clé de données lors de la création du domaine APM.

2. Créez un système de fichiers qui montera les pods.

   Lors de la création du système de fichiers, il est important de sélectionner le même compartiment de réseau cloud virtuel (VCN) que celui utilisé par Kubernetes. Faites de même pour le compartiment de sous-réseau.

3. Montez le système de fichiers dans les pods.

   Cette étape nécessite des modifications des fichiers yaml correspondants.

   Créez le fichier PersistentVolume et les entités associées dans Kubernetes, à l'aide du fichier yaml ci-dessous. Notez les champs suivants à modifier pour votre environnement : mntTargetId, server et path.

   kind: StorageClass
   apiVersion: storage.k8s.io/v1
   metadata:
     name: oci-fss
   provisioner: oracle.com/oci-fss
   parameters:
     mntTargetId: ocid1.mounttarget.oc1.iad.xxxxxxxxxxxxxxxxxxxxxx
   ---
   apiVersion: v1
   kind: PersistentVolume
   metadata:
    name: oke-fsspv
   spec:
    storageClassName: oci-fss
    capacity:
     storage: 10Gi
    accessModes:
     - ReadWriteMany
    mountOptions:
     - nosuid
    nfs:
   # Replace this with the IP of your FSS file system in OCI
     server: 10.0.10.39
   # Replace this with the Path of your FSS file system in OCI
     path: "/fss-for-kub"
     readOnly: false
   ---
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
    name: oke-fsspvc
   spec:
    storageClassName: oci-fss
    accessModes:
    - ReadWriteMany
    resources:
     requests:
    # Although storage is provided here it is not used for FSS file systems
       storage: 10Gi
    volumeName: oke-fsspv

   Pour appliquer les modifications, exécutez kubectl apply -f <filename.yaml>

   Ensuite, mettez à jour le fichier yaml qui gère les pods et ajoutez le volume et le montage de volume.

   Pour prendre effet, recréez les pods.

4. Téléchargez le fichier d'agent Java APM.

   Téléchargez et copiez le fichier sur le volume monté.

   Pour obtenir des instructions de téléchargement, reportez-vous à Téléchargement du logiciel d'agent Java APM.

   Après le téléchargement, copiez-le sur le volume monté.

5. Provisionnement de l'agent Java APM.

   Connectez-vous à l'un des conteneurs pour provisionner l'agent Java APM, localisez le fichier jar apm-java-agent-installer et exécutez la commande suivante :

   java -jar ./apm-java-agent-installer-<version>.jar provision-agent -service-name=<Name of the Service> -destination=<Destination_Directory> -private-data-key=<Agent installation key generated during APM domain creation> -data-upload-endpoint=<dataUploadEndpoint URL generated during APM domain creation>

   Pour obtenir des instructions sur le provisionnement, reportez-vous à Provisionnement de l'agent Java APM.

6. Déploiement de l'agent Java APM.

   Déployez l'agent Java APM en fournissant l'emplacement oracle-apm-agent au microservice dans le fichier yaml.

   Ajoutez l'argument -javaagent et l'emplacement du fichier JAR de l'agent APM à la commande java de chaque microservice :

   java -javaagent:<Mounted Volume>/oracle-apm-agent/bootstrap/ApmAgent.jar

7. Redémarrez Kubernetes.

   Recréez les pods en exécutant kubectl apply -f <filename.yaml>.

   Vous pouvez maintenant passer à l'étape suivante : Vérifier le déploiement de l'agent Java APM.