Habilitación de Application Signals en los clústeres de Amazon EKS

Para habilitar Application Signals para aplicaciones en un clúster de Amazon EKS existente

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.

2. Seleccione Application Signals.

3. En Especificar plataforma, elija EKS.

4. En Seleccionar un clúster EKS, seleccione el clúster en el que desee habilitar Application Signals.

5. Si este clúster aún no tiene habilitado el complemento Observabilidad de Amazon CloudWatch en EKS, se le solicitará que lo habilite. En este caso, realice lo siguiente:

   1. Seleccione Añadir el complemento de observabilidad CloudWatch de EKS. Aparece la consola de Amazon EKS.

   2. Seleccione la casilla Observabilidad de Amazon CloudWatch y elija Siguiente.

      El complemento CloudWatch Observability de EKS brinda tanto a Application Signals como a Información de contenedores de CloudWatch capacidad de observabilidad mejorada para Amazon EKS. Para obtener más información sobre Información de contenedores, consulte Información de contenedores.

   3. Seleccione la versión más reciente del complemento para instalar.

   4. Seleccione un rol de IAM para usarlo en el complemento. Si elige Heredar del nodo, asocie los permisos correctos al rol de IAM utilizado por los nodos de trabajo. Sustituya my-worker-node-role por el rol de IAM que utilizan sus nodos de trabajo de Kubernetes.

      aws iam attach-role-policy \
      --role-name my-worker-node-role \
      --policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
      --policy-arn arn:aws:iam::aws:policy/AWSXRayWriteOnlyAccess

   5. Si desea crear un rol de servicio para utilizar el complemento, consulteInstalación del agente de CloudWatch con el complemento de observabilidad de EKS de Amazon CloudWatch o el gráfico de Helm.

   6. Seleccione Siguiente, confirme la información de la pantalla y seleccione Crear.

   7. En la siguiente pantalla, seleccione Habilitar CloudWatch Application Signals para volver a la consola de CloudWatch y finalizar el proceso.

6. Hay dos opciones para habilitar sus aplicaciones para Application Signals. Para mantener la coherencia, recomendamos elegir una opción por clúster.

   • La opción de consola es más sencilla. El uso de este método hace que los pods se reinicien inmediatamente.

   • El método Annotate Manifest File le brinda más control sobre cuándo se reinician sus pods y también puede ayudarlo a administrar su supervisión de una manera más descentralizada si no desea centralizarlo.

   nota

   Si desea habilitar Application Signals para una aplicación Node.js con ESM, consulte Configuración de una aplicación Node.js con el formato de módulo ESM.

   Console

   La opción de consola usa la configuración avanzada del complemento de EKS de observabilidad de Amazon CloudWatch para configurar Application Signals para sus servicios. Para obtener más información acerca del complemento, consulte Configuraciones adicionales (Opcional).

   Si no ve una lista de cargas de trabajo y espacios de nombres, asegúrese de tener los permisos correctos para verlos en este clúster. Para obtener más información, consulte Permisos necesarios.

   Puede supervisar todas las cargas de trabajo de los servicios seleccionando la casilla Auto monitor o elegir de forma selectiva cargas de trabajo y espacios de nombres específicos para supervisar.

   Para supervisar todas las cargas de trabajo del servicio con Auto monitor:

   1. Seleccione la casilla Auto monitor para elegir automáticamente todas las cargas de trabajo del servicio de un clúster.

   2. Elija Auto restart para reiniciar todos los pods de carga de trabajo y activar Application Signals de forma inmediata con los SDK de instrumentación automática de AWS Distro para OpenTelemetry (ADOT) integrados en sus pods.

   3. Seleccione Listo. Cuando se selecciona Auto restart, el complemento del EKS de observabilidad de CloudWatch activará Application Signals de forma inmediata. De lo contrario, Application Signals se habilitará durante la siguiente implementación de cada carga de trabajo.

   Puede supervisar cargas de trabajo individuales o espacios de nombres completos.

   Para supervisar una sola carga de trabajo:

   1. Seleccione la casilla de verificación junto a la carga de trabajo que desea supervisar.

   2. Utilice la lista desplegable Seleccionar lenguajes para seleccionar el idioma de la carga de trabajo. Seleccione los idiomas en los que desee habilitar Application Signals y, a continuación, seleccione el icono de marca de verificación (✓) para guardar esta selección.

      En el caso de las aplicaciones Python, asegúrese de que la aplicación cumpla los requisitos previos necesarios antes de continuar. Para obtener más información, consulte La aplicación Python no se inicia después de activar Application Signals.

   3. Seleccione Listo. El complemento de EKS de observabilidad de Amazon CloudWatch inyectará inmediatamente los SDK de AWS Distro para OpenTelemetry autoinstrumentation (ADOT) en sus pods y activará reinicios de pods para permitir la recopilación de métricas y seguimientos de aplicaciones.

   Para supervisar un espacio de nombres completo:

   1. Seleccione la casilla de verificación junto al espacio de nombres que desea supervisar.

   2. Utilice la lista desplegable Seleccionar lenguajes para seleccionar el idioma del espacio de nombres. Seleccione los idiomas en los que desee habilitar Application Signals y, a continuación, seleccione el icono de marca de verificación (✓) para guardar esta selección. Esto se aplica a todas las cargas de trabajo de este espacio de nombres, tanto si están implementadas actualmente como si se implementarán en el futuro.

      En el caso de las aplicaciones Python, asegúrese de que la aplicación cumpla los requisitos previos necesarios antes de continuar. Para obtener más información, consulte La aplicación Python no se inicia después de activar Application Signals.

   3. Seleccione Listo. El complemento de EKS de observabilidad de Amazon CloudWatch inyectará inmediatamente los SDK de AWS Distro para OpenTelemetry autoinstrumentation (ADOT) en sus pods y activará reinicios de pods para permitir la recopilación de métricas y seguimientos de aplicaciones.

   Para habilitar Application Signals en otro clúster de Amazon EKS, seleccione Habilitar Application Signals en la pantalla Servicios.

   Annotate manifest file

   En la consola de CloudWatch, la sección Servicios del monitor explica que debe agregar una anotación a un manifiesto YAML en el clúster. La adición de esta anotación instrumenta automáticamente la aplicación para enviar métricas, seguimientos y registros a Application Signals.

   Dispone de dos opciones para realizar la anotación:

   • Anotar carga de trabajo instrumenta automáticamente una sola carga de trabajo en el clúster.

   • Anotar el espacio de nombres instrumenta automáticamente todas las cargas de trabajo desplegadas en el espacio de nombres seleccionado.

   Elija una de esas opciones y siga los pasos correspondientes:

   • Para anotar una sola carga de trabajo:

     1. Elija Anotar carga de trabajo.

     2. Pegue una de las siguientes líneas en la sección PodTemplate del archivo de manifiesto de carga de trabajo.

        • Para cargas de trabajo Java: annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • Para cargas de trabajo Python: annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Para las aplicaciones Python, se requieren configuraciones adicionales. Para obtener más información, consulte La aplicación Python no se inicia después de activar Application Signals.

        • Para cargas de trabajo de .NET annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

          nota

          Para habilitar Application Signals para una carga de trabajo de .NET en imágenes basadas en Alpine Linux (linux-musl-x64), agregue la siguiente anotación.

          instrumentation.opentelemetry.io/otel-dotnet-auto-runtime: "linux-musl-x64"

        • Para cargas de trabajo de Node.js: annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. En la terminal, ingrese kubectl apply -f your_deployment_yaml para aplicar el cambio.

   • Para anotar todas las cargas de trabajo en un espacio de nombres:

     1. Seleccione Anotar el espacio de nombres.

     2. Pegue una de las siguientes líneas en la sección de metadatos del archivo de manifiesto del espacio de nombres. Si el espacio de nombres incluye cargas de trabajo de Java, Python y .NET, pegue estas dos líneas en el archivo de manifiesto del espacio de nombres.

        • Si hay cargas de trabajo Java en el espacio de nombres: annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • Si hay cargas de trabajo Python en el espacio de nombres: annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Para las aplicaciones Python, se requieren configuraciones adicionales. Para obtener más información, consulte La aplicación Python no se inicia después de activar Application Signals.

        • Si hay cargas de trabajo de .NET en el espacio de nombres: annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

        • Si hay cargas de trabajo de Node.js en el namespace: annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. En la terminal, ingrese kubectl apply -f your_namespace_yaml para aplicar el cambio.

     4. En la terminal, introduzca un comando para reiniciar todos los pods del espacio de nombres. Un ejemplo de comando para reiniciar las cargas de trabajo de implementación es kubectl rollout restart deployment -n namespace_name

7. Elija Ver servicios cuando haya terminado. Esto lo llevará a la vista de los servicios de Application Signals, donde podrá ver los datos que Application Signals recopila. Es posible que se tarde unos minutos en mostrar los datos.

   Para habilitar Application Signals en otro clúster de Amazon EKS, seleccione Habilitar Application Signals en la pantalla Servicios.

   Para obtener más información sobre la vista de los Servicios, consulte Monitoreo del estado operativo de sus aplicaciones con Application Signals.

Para habilitar Application Signals para una aplicación Node.js con ESM

1. Instale en su aplicación Node.js las dependencias pertinentes para la autoinstrumentación:

   npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
   npm install @opentelemetry/instrumentation@0.54.0

2. Agregue las siguientes variables de entorno al archivo Dockerfile de su aplicación y cree la imagen.

   ...
   ENV OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true
   ENV OTEL_TRACES_SAMPLER_ARG='endpoint=http://cloudwatch-agent.amazon-cloudwatch:2000'
   ENV OTEL_TRACES_SAMPLER='xray'
   ENV OTEL_EXPORTER_OTLP_PROTOCOL='http/protobuf'
   ENV OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/traces'
   ENV OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/metrics'
   ENV OTEL_METRICS_EXPORTER='none'
   ENV OTEL_LOGS_EXPORTER='none'
   ENV NODE_OPTIONS='--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs'
   ENV OTEL_SERVICE_NAME='YOUR_SERVICE_NAME' #replace with a proper service name
   ENV OTEL_PROPAGATORS='tracecontext,baggage,b3,xray'
   ...
   
   # command to start the application
   # for example
   # CMD ["node", "index.mjs"]

3. Agregue las variables de entorno OTEL_RESOURCE_ATTRIBUTES_POD_NAME, OTEL_RESOURCE_ATTRIBUTES_NODE_NAME, OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME, POD_NAMESPACE y OTEL_RESOURCE_ATTRIBUTES al archivo de implementación yaml de la aplicación. Por ejemplo:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nodejs-app
     labels:
       app: nodejs-app
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: nodejs-app
     template:
       metadata:
         labels:
           app: nodejs-app
         # annotations:
         # make sure this annotation doesn't exit
         #   instrumentation.opentelemetry.io/inject-nodejs: 'true'
       spec:
         containers:
         - name: nodejs-app
           image:your-nodejs-application-image #replace with a proper image uri
           imagePullPolicy: Always
           ports:
           - containerPort: 8000
           env:
             - name: OTEL_RESOURCE_ATTRIBUTES_POD_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.name
             - name: OTEL_RESOURCE_ATTRIBUTES_NODE_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: spec.nodeName
             - name: OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.labels['app'] # Assuming 'app' label is set to the deployment name
             - name: POD_NAMESPACE
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.namespace
             - name: OTEL_RESOURCE_ATTRIBUTES
               value: "k8s.deployment.name=$(OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME),k8s.namespace.name=$(POD_NAMESPACE),k8s.node.name=$(OTEL_RESOURCE_ATTRIBUTES_NODE_NAME),k8s.pod.name=$(OTEL_RESOURCE_ATTRIBUTES_POD_NAME)"

4. Implemente la aplicación Node.js en el clúster.

1. Habilite Application Signals para sus aplicaciones

   import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib';
   
   const cfnDiscovery = new applicationsignals.CfnDiscovery(this,
     'ApplicationSignalsServiceRole', { }
   );

   El recurso Discovery de CloudFormation otorga a Application Signals los siguientes permisos:

   • xray:GetServiceGraph

   • logs:StartQuery

   • logs:GetQueryResults

   • cloudwatch:GetMetricData

   • cloudwatch:ListMetrics

   • tag:GetResources

   Para obtener más información acerca de este rol, consulte Permisos de roles vinculados a un servicio para CloudWatch Application Signals.

2. Instale el complemento amazon-cloudwatch-observability.

   1. Cree un rol de IAM con la CloudWatchAgentServerPolicy y el OIDC asociado al clúster.

      const cloudwatchRole = new Role(this, 'CloudWatchAgentAddOnRole', {
          assumedBy: new OpenIdConnectPrincipal(cluster.openIdConnectProvider),
          managedPolicies: [ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy')],
      });

3. Instale el complemento con el rol de IAM creado anteriormente.

   new CfnAddon(this, 'CloudWatchAddon', {
       addonName: 'amazon-cloudwatch-observability',
       clusterName: cluster.clusterName,
       serviceAccountRoleArn: cloudwatchRole.roleArn
   });

4. Añada una de las siguientes opciones en la sección PodTemplate del archivo de manifiesto de carga de trabajo.

   Idioma	Archivos
   Java	instrumentation.opentelemetry.io/inject-java: "true"
   Python	instrumentation.opentelemetry.io/inject-python: "true"
   .Net	instrumentation.opentelemetry.io/inject-dotnet: "true"
   Node.js	instrumentation.opentelemetry.io/inject-nodejs: "true"

   const deployment = {
     apiVersion: "apps/v1",
     kind: "Deployment",
     metadata: { name: "sample-app" },
     spec: {
       replicas: 3,
       selector: {
         matchLabels: {
           "app": "sample-app"
         }
       },
       template: {
         metadata: {
           labels: {
             "app": "sample-app"
           },
           annotations: {
             "instrumentation.opentelemetry.io/inject-$LANG": "true"
           }
         },
         spec: {...},
       },
     },
   };
   
   cluster.addManifest('sample-app', deployment)