Para implantar o agente Java do APM, siga as etapas abaixo:

1. Antes de continuar, confirme se você concluiu os pré-requisitos e o agente Java do APM provisionado.
   Observação
   
   Ao provisionar o agente Java do APM, é recomendável provisioná-lo em qualquer local da sua máquina local e, em seguida, copiá-lo para uma imagem do Docker.
2. Modifique seu Dockerfile para copiar o agente Java do APM para uma imagem do Docker:

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

   Observe que <DESTINATION_DIRECTORY> denota o local em sua máquina local na qual você provisionou o agente Java do APM e <Docker_Image_Directory> denota o diretório na imagem do Docker para o qual você está copiando o agente Java do APM. O <Docker_Image_Directory> também poderia ser o diretório de destino do servidor de aplicativos no Docker, por exemplo, $DOMAIN_HOME, se você estiver trabalhando com o Oracle WebLogic Server.

3. Adicione a seguinte opção -javaagent ao script de inicialização do servidor de aplicativos:

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

4. Crie uma nova imagem do Docker com o agente Java do APM incorporado e o script de inicialização modificado e envie a imagem para o registro.

Se você usar o Kubernetes para gerenciar seus contêineres do Docker, atualize a sua configuração do Kubernetes para usar a nova imagem do Docker e reinicie o pod do Kubernetes.

Além disso, você pode definir dimensões adicionais a serem reportadas do pod do Kubernetes usando a API Downward, copiando as seguintes definições de ambiente e volume na especificação de implantação (arquivo yaml) do pod do Kubernetes. Para obter informações sobre a API Downward, consulte The Downward API na documentação do Kubernetes.

Definições de Ambiente

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

Definições 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é-requisito: Instale o Operador OpenTelemetry no cluster do Kubernetes.

Há três opções diferentes disponíveis: Manifesto de release do operador, Gráfico helm do operador ou Hub do Operador.

Na maioria dos casos, um cert-manager deve ser instalado. Se a opção de gráfico helm for usada, haverá uma opção para gerar um certificado autoassinado.

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

Para instalar o operador OpenTelemetry, execute o seguinte:

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

Implantar o agente Java do APM

Para implantar o agente Java do APM, siga estas etapas:

1. Criar um Recurso Personalizado (CR) do Kubernetes.

   Para gerenciar a instrumentação automática, o Operador OpenTelemetry precisa receber informações sobre o agente Java do APM e sua configuração, que é feita usando a Definição de Recurso Personalizado (CRD).

   Este Recurso Personalizado será usado pelo operador para copiar o agente no pod e adicionar a ele a configuração necessária.

   Para criar o CR, execute o seguinte:

   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

   Em que:

   • <data-upload-endpoint> é o URL do ponto final de upload de dados que é gerado quando o domínio do APM é criado. Para obter informações, consulte Obter Ponto Final de Upload de Dados e Chaves de Dados.
   • <private-data-key> é a chave de dados privada de instalação do agente Java do APM que é gerada quando o domínio do APM é criado. Para obter informações, consulte Obter Ponto Final de Upload de Dados e Chaves de Dados.
   O CR criado pode ser consultado executando o seguinte comando:

   kubectl get otelinst -n opentelemetry-operator-system

   Todos os pontos finais e variáveis de ambiente devem estar corretos para que a instrução automática funcione corretamente.
2. Adicione a anotação do Kubernetes.

   O operador OpenTelemetry usa a anotação do Kubernetes para decidir quais pods devem ser injetados automaticamente com o agente Java do APM.

   A anotação pode ser adicionada a um namespace. Nesse caso, todos os pods dentro desse namespace serão injetados. A anotação também pode ser adicionada a objetos PodSpec individuais, disponíveis como parte da Implantação, Statefulset e outros recursos.

   Nota:

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

   Para começar a editar seu namespace, faça o seguinte:

   • Execute o comando:

     kubectl edit namespace <your-namespace-name>

   • Edite o namespace assim que o editor for aberto. Por exemplo, editor vi.
   • Adicione a anotação ao namespace. Tenha em mente que o recuo é muito importante para torná-lo um arquivo YAML válido.
   Exemplo:

   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 o pod do Kubernetes.

   Para reiniciar o pod no qual você deseja injetar automaticamente o agente Java do APM, execute o seguinte:

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

4. Verifique o pod do Kubernetes.
   Para verificar se seu pod foi injetado automaticamente com o agente Java do APM depois que ele foi reiniciado, execute o seguinte:

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

Agora você pode ir para a próxima etapa: Verificar Implantação do Agente Java do APM.

Para implantar o agente Java do APM em um volume montado, siga estas etapas:

1. Confirme se você concluiu as tarefas de pré-requisito do agente Java do APM.

   Anote o ponto final de upload de dados e a chave de dados quando o Domínio do APM tiver sido criado.

2. Crie um novo sistema de arquivos que montará os pods.

   Ao criar o sistema de arquivos, é importante garantir a seleção do mesmo Compartimento de Rede Virtual na Nuvem (VCN) que o Kubernetes está usando. Faça o mesmo para o Compartimento de Sub-rede.

3. Monte o sistema de arquivos nos pods.

   Esta etapa requer edições nos arquivos yaml correspondentes.

   Crie o PersistentVolume e as entidades relacionadas no Kubernetes, usando o arquivo yaml abaixo. Observe os seguintes campos que você precisa editar para seu ambiente: mntTargetId, server e 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 as alterações, execute kubectl apply -f <filename.yaml>

   Em seguida, atualize o arquivo yaml que gerencia os pods e adicione a montagem de volume e volume.

   Para entrar em vigor, recrie os pods.

4. Faça download do arquivo do agente Java do APM.

   Faça download do arquivo e copie-o para o volume montado.

   Para obter instruções de download, consulte Fazer Download do Software do Agente Java do APM.

   Após o download, copie-o para o volume montado.

5. Provisionar o Agente Java do APM.

   Faça log-in em um dos contêineres para provisionar o Agente Java do APM, localize o arquivo jar apm-java-agent-installer e execute o seguinte:

   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 obter instruções de provisionamento, consulte Provisionar o Agente Java do APM.

6. Implantar o Agente Java do APM.

   Implante o Java Agent do APM fornecendo o local oracle-apm-agent para o microsserviço no arquivo yaml.

   Adicione o argumento -javaagent e o local do arquivo jar do agente do APM ao comando java de cada microsserviço:

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

7. Reinicie o Kubernetes.

   Recrie os pods executando: kubectl apply -f <filename.yaml>.

   Agora você pode ir para a próxima etapa: Verificar Implantação do Agente Java do APM.