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

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

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

   Notez que <DESTINATION_DIRECTORY> indique l'emplacement sur votre machine locale où vous avez provisionné l'agent Java APM et <Docker_Image_Directory> indique le répertoire dans l'image Docker où vous copiez l'agent Java APM. <Docker_Image_Directory> peut également être 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 de votre serveur d'applications :

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

4. Créez une nouvelle image Docker avec l'agent Java APM intégré et le script de démarrage modifié, puis poussez l'image vers le registre.

Si vous utilisez Kubernetes pour gérer vos conteneurs Docker, mettez à jour votre configuration Kubernetes afin d'utiliser la nouvelle image Docker et redémarrez le pod Kubernetes.

Vous pouvez également définir des dimensions supplémentaires à déclarer à partir du pod Kubernetes à l'aide de l'API descendante, en copiant les paramètres d'environnement et de volume suivants dans la spécification de déploiement (fichier yaml) du pod Kubernetes. Pour plus d'informations sur l'API descendante, voir API descendante dans la documentation sur Kubernetes.

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éalable : Installez l'opérateur OpenTelemetry dans la grappe Kubernetes.

Trois options sont disponibles : Manifeste de lancement d'opérateur, Graphique d'aide de l'opérateur ou Operator Hub.

Dans la plupart des cas, un gestionnaire de certificats doit être installé. Si l'option de graphique de commande est utilisée, il existe une option pour générer un certificat auto-signé.

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 les opérations suivantes :

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 à 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 le CR, exécutez les opérations suivantes :

   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 du point d'extrémité de chargement des données générée lors de la création du domaine APM. Pour plus d'informations, voir Obtenir un point d'extrémité de chargement de données et des clés de données.
   • <private-data-key> est la clé de données privée d'installation de l'agent Java APM qui est générée lors de la création du domaine APM. Pour plus d'informations, voir Obtenir un point d'extrémité de chargement de données et des clés de données.
   Le CR créé peut être interrogé en exécutant la commande suivante :

   kubectl get otelinst -n opentelemetry-operator-system

   Tous les points d'extrémité 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écider quels pods doivent être injectés 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 suivante :

     kubectl edit namespace <your-namespace-name>

   • Modifiez l'espace de noms une fois l'éditeur ouvert. Par exemple, l'é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 module de réseautage Kubernetes.

   Pour redémarrer le pod où vous voulez injecter automatiquement l'agent Java APM, exécutez les opérations suivantes :

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

4. Vérifiez le pod Kubernetes.
   Pour vérifier que votre 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. Confirmez que vous avez terminé les tâches préalables de l'agent Java APM.

   Notez le point d'extrémité et la clé de données de chargement des 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 en nuage 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 PersistentVolume et les entités connexes dans Kubernetes, à l'aide du fichier yaml ci-dessous. Notez les champs suivants que vous devez 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>

   Mettez ensuite à jour le fichier yaml qui gère les pods et ajoutez le montage du volume et du volume.

   Pour prendre effet, recréez les pods.

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

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

   Pour obtenir des instructions de téléchargement, voir Télécharger le logiciel de l'agent Java APM.

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

5. Provisionner 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 les opérations suivantes :

   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 de provisionnement, voir Provisionner l'agent Java APM.

6. Déployer 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.