Para desplegar el agente Java de APM, siga estos pasos:

1. Antes de continuar, confirme que ha completado los requisitos previos y aprovisionado el agente Java de APM.
   Nota
   
   Al aprovisionar el agente Java de APM, se recomienda aprovisionarlo en cualquier ubicación de la máquina local y, a continuación, copiarlo en una imagen de Docker.
2. Modifique el archivo Dockerfile para copiar el agente Java de APM en una imagen de Docker:

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

   Tenga en cuenta que <DESTINATION_DIRECTORY> indica la ubicación en la máquina local en la que ha aprovisionado el agente Java de APM y <Docker_Image_Directory> indica el directorio de la imagen de Docker en la que va a copiar el agente Java de APM. <Docker_Image_Directory> también puede ser el directorio de destino del servidor de aplicaciones en Docker; por ejemplo, $DOMAIN_HOME, si está trabajando con Oracle WebLogic Server.

3. Agregue la siguiente opción de -javaagent al script de inicio del servidor de aplicaciones:

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

4. Cree una nueva imagen de Docker con el agente Java de APM incorporado y el script de inicio modificado, y transfiera la imagen al registro.

Si utiliza Kubernetes para gestionar los contenedores del Docker, actualice la configuración de Kubernetes para utilizar la nueva imagen de Docker y reinicie el pod de Kubernetes.

Además, puede definir las dimensiones adicionales que se notificarán desde el pod de Kubernetes mediante la API descendente copiando la siguiente configuración de volumen y entorno en la especificación de despliegue (archivo yaml) del pod de Kubernetes. Para obtener información sobre la API descendente, consulte la sección correspondiente (The Downward API) en la documentación de Kubernetes.

Configuración del entorno

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

Configuración del volumen

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

Requisito: instale el operador OpenTelemetry en el cluster de Kubernetes.

Hay tres opciones diferentes disponibles: Manifiesto de versión de operador, Gráfico de cabecera de operador o Hub de operador.

En la mayoría de los casos, se debe instalar un cert-manager. Si se utiliza la opción de gráfico de timón, hay una opción para generar un certificado autofirmado.

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

Para instalar el operador OpenTelemetry, ejecute lo siguiente:

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

Desplegar el agente Java de APM

Para desplegar el agente Java de APM, siga estos pasos:

1. Crear un recurso personalizado (CR) de Kubernetes.

   Para gestionar la instrumentación automática, se debe proporcionar al operador OpenTelemetry información sobre el agente Java de APM y su configuración mediante la definición de recurso personalizado (CRD).

   El operador utilizará este recurso personalizado para copiar el agente en el pod y agregarle la configuración necesaria.

   Para crear la CR, ejecute lo siguiente:

   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

   Donde:

   • <data-upload-endpoint> es la URL de punto final de carga de datos que se genera cuando se crea el dominio de APM. Para obtener información, consulte Cómo obtener el punto final de carga de datos y las claves de datos.
   • <private-data-key> es la clave de datos privados de instalación del agente Java de APM que se genera cuando se crea el dominio de APM. Para obtener información, consulte Cómo obtener el punto final de carga de datos y las claves de datos.
   La CR creada se puede consultar ejecutando el siguiente comando:

   kubectl get otelinst -n opentelemetry-operator-system

   Todos los puntos finales y variables de entorno deben ser correctos para que la instrumentación automática funcione correctamente.
2. Agregue la anotación de Kubernetes.

   El operador OpenTelemetry utiliza la anotación de Kubernetes para decidir qué pods se deben inyectar automáticamente con el agente Java de APM.

   La anotación se puede agregar a un espacio de nombres. En ese caso, se inyectarán todos los pods dentro de ese espacio de nombres. La anotación también se puede agregar a objetos PodSpec individuales, disponibles como parte de Deployment, Statefulset y otros recursos.

   Nota:

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

   Para empezar a editar el espacio de nombres, haga lo siguiente:

   • Ejecute el comando:

     kubectl edit namespace <your-namespace-name>

   • Edite el espacio de nombres una vez abierto el editor. Por ejemplo, editor vi.
   • Agregue la anotación al espacio de nombres. Tenga en cuenta que la sangría es muy importante para que sea un archivo YAML válido.
   Por ejemplo:

   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. Reinicie el pod de Kubernetes.

   Para reiniciar el pod donde desea inyectar automáticamente el agente Java de APM, ejecute lo siguiente:

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

4. Verifique el pod de Kubernetes.
   Para verificar que el pod se haya inyectado automáticamente con el agente Java de APM después de reiniciar, ejecute lo siguiente:

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

Ahora puede ir al siguiente paso: Verificar despliegue de agente Java de APM.

Para desplegar el agente Java de APM en un volumen montado, siga estos pasos:

1. Confirme que ha completado las tareas de requisitos del agente Java de APM.

   Anote el punto final de carga de datos y la clave de datos cuando se haya creado el dominio de APM.

2. Cree un nuevo sistema de archivos que monte los pods.

   Al crear el sistema de archivos, es importante asegurarse de seleccionar el mismo compartimento de red virtual en la nube (VCN) que utiliza Kubernetes. Haga lo mismo para el compartimento de subred.

3. Monte el sistema de archivos en los pods.

   Este paso requiere ediciones en los archivos yaml correspondientes.

   Cree PersistentVolume y las entidades relacionadas en Kubernetes mediante el siguiente archivo yaml. Tenga en cuenta los siguientes campos que necesita editar para su entorno: mntTargetId, server y 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

   Para aplicar los cambios, ejecute kubectl apply -f <filename.yaml>

   A continuación, actualice el archivo yaml que gestiona los pods y agregue el montaje de volumen y volumen.

   Para que surta efecto, vuelva a crear los pods.

4. Descargue el archivo de agente de Java APM.

   Descargue y copie el archivo en el volumen montado.

   Para obtener instrucciones de descarga, consulte Descarga del software del agente Java de APM.

   Después de descargarlo, cópielo en el volumen montado.

5. Aprovisionamiento del agente Java de APM.

   Conéctese a uno de los contenedores para aprovisionar el agente Java de APM, busque el archivo jar apm-java-agent-installer y ejecute lo siguiente:

   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>

   Para obtener instrucciones de aprovisionamiento, consulte Aprovisionamiento del agente Java de APM.

6. Despliegue del agente Java de APM.

   Despliegue el agente Java de APM proporcionando la ubicación oracle-apm-agent al microservicio en el archivo yaml.

   Agregue el argumento -javaagent y la ubicación del archivo jar del agente de APM al comando java de cada microservicio:

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

7. Reinicie Kubernetes.

   Vuelva a crear los pods ejecutando: kubectl apply -f <filename.yaml>.

   Ahora puede ir al siguiente paso: Verificar despliegue de agente Java de APM.