Abilitazione delle applicazioni sui cluster Amazon EKS

Per abilitare Application Signals per le applicazioni su un cluster Amazon EKS esistente

1. Apri la CloudWatch console all'indirizzo https://console.aws.amazon.com/cloudwatch/.

2. Scegli Application Signals.

3. Per Specifica piattaforma, scegli EKS.

4. Per Seleziona un cluster EKS, scegli il cluster in cui desideri abilitare Application Signals.

5. Se questo cluster non ha già il componente aggiuntivo Amazon CloudWatch Observability EKS abilitato, ti verrà richiesto di abilitarlo. In questo caso, puoi fare quanto segue:

   1. Scegli il componente aggiuntivo Add CloudWatch Observability EKS. Viene visualizzata la console Amazon EKS.

   2. Seleziona la casella di controllo per Amazon CloudWatch Observability e scegli Avanti.

      Il componente aggiuntivo CloudWatch Observability EKS abilita sia Application Signals che CloudWatch Container Insights con una migliore osservabilità per Amazon EKS. Per ulteriori informazioni su Container Insights, consulta Container Insights.

   3. Seleziona la versione più recente del componente aggiuntivo da installare.

   4. Seleziona un ruolo IAM da utilizzare per il componente aggiuntivo. Se scegli Eredita dal nodo, assegna le autorizzazioni corrette per il ruolo IAM utilizzato dai tuoi nodi worker. my-worker-node-roleSostituiscilo con il ruolo IAM utilizzato dai nodi di lavoro 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. Per creare un ruolo di servizio per l'utilizzo del componente aggiuntivo, consulta Installa l' CloudWatch agente con il componente aggiuntivo Amazon CloudWatch Observability EKS o il grafico Helm.

   6. Scegli Successivo, conferma le informazioni sullo schermo e scegli Crea.

   7. Nella schermata successiva, scegli Enable CloudWatch Application Signals per tornare alla CloudWatch console e completare il processo.

6. Esistono due opzioni per abilitare le applicazioni per Application Signals. Per coerenza, consigliamo di scegliere una singola opzione per ciascun cluster.

   • L'opzione Console è più semplice. Utilizzando questo metodo, i pod si riavviano immediatamente.

   • Il metodo Annota il file manifesto offre un maggiore controllo sul momento in cui i pod si riavviano e può anche facilitare la gestione del monitoraggio in modo più decentralizzato, se non desideri centralizzarlo.

   Nota

   Se stai abilitando Application Signals per un'applicazione Node.js con ESM, vai direttamente a Configurazione di un'applicazione Node.js con il formato del modulo ESM.

   Console

   L'opzione Console utilizza la configurazione avanzata del componente aggiuntivo Amazon CloudWatch Observability EKS per configurare Application Signals per i tuoi servizi. Per ulteriori informazioni sul componente aggiuntivo, consulta (Facoltativo) Configurazione aggiuntiva.

   Se non vedi un elenco di carichi di lavoro e namespace, assicurati di disporre delle autorizzazioni giuste per visualizzarli per questo cluster. Per ulteriori informazioni, consulta Autorizzazioni richieste.

   Puoi monitorare tutti i carichi di lavoro del servizio selezionando la casella di controllo Monitor automatico o scegliere selettivamente carichi di lavoro e namespace specifici da monitorare.

   Per monitorare tutti i carichi di lavoro del servizio con Monitor automatico:

   1. Seleziona la casella di controllo Monitor automatico per selezionare automaticamente tutti i carichi di lavoro del servizio in un cluster.

   2. Scegli Riavvio automatico per riavviare tutti i pod del carico di lavoro e abilitare immediatamente Application Signals con AWS Distro for OpenTelemetry auto-instrumentation (ADOT) iniettato nei tuoi pod. SDKs

   3. Seleziona Fatto. Quando è selezionato il riavvio automatico, il componente aggiuntivo Observability EKS abiliterà immediatamente Application Signals CloudWatch . In caso contrario, Application Signals verrà abilitato durante la successiva implementazione di ogni carico di lavoro.

   È possibile monitorare singoli carichi di lavoro o interi namespace.

   Per monitorare un singolo carico di lavoro:

   1. Seleziona la casella di controllo accanto al carico di lavoro da monitorare.

   2. Utilizza l'elenco a discesa Seleziona lingua(e) per selezionare la lingua del carico di lavoro. Seleziona le lingue per le quali desideri abilitare Application Signals, quindi scegli l'icona del segno di spunta (✓) per salvare la selezione.

      Per le applicazioni Python, assicurati che l'applicazione soddisfi i prerequisiti richiesti prima di continuare. Per ulteriori informazioni, consulta L'applicazione Python non si avvia dopo l'abilitazione di Application Signals.

   3. Seleziona Fatto. Il componente aggiuntivo Amazon CloudWatch Observability EKS inietterà immediatamente AWS Distro for OpenTelemetry autoinstrumentation (ADOT) SDKs nei tuoi pod e attiverà il riavvio del pod per consentire la raccolta di metriche e tracce dell'applicazione.

   Per monitorare un intero namespace:

   1. Seleziona la casella di controllo accanto al namespace da monitorare.

   2. Utilizza l'elenco a discesa Seleziona lingua(e) per selezionare la lingua del namespace. Seleziona le lingue per le quali desideri abilitare Application Signals, quindi scegli l'icona del segno di spunta (✓) per salvare la selezione. Ciò vale per tutti i carichi di lavoro in questo namespace, indipendentemente dal fatto che siano già stati implementati o che verranno implementati in futuro.

      Per le applicazioni Python, assicurati che l'applicazione soddisfi i prerequisiti richiesti prima di continuare. Per ulteriori informazioni, consulta L'applicazione Python non si avvia dopo l'abilitazione di Application Signals.

   3. Seleziona Fatto. Il componente aggiuntivo Amazon CloudWatch Observability EKS inietterà immediatamente AWS Distro for OpenTelemetry autoinstrumentation (ADOT) SDKs nei tuoi pod e attiverà il riavvio del pod per consentire la raccolta di metriche e tracce dell'applicazione.

   Per abilitare Application Signals in un altro cluster Amazon EKS, scegli Abilita Application Signals dalla schermata Servizi.

   Annotate manifest file

   Nella CloudWatch console, la sezione Monitor Services spiega che è necessario aggiungere un'annotazione a un file YAML manifesto nel cluster. L'aggiunta di questa annotazione strumenta automaticamente l'applicazione per inviare parametri, tracciamenti e log ad Application Signals.

   Sono disponibili due opzioni per l'annotazione:

   • Annotazione del carico di lavoro strumenta automaticamente un singolo carico di lavoro nel cluster.

   • Annotazione dello spazio dei nomi strumenta automaticamente tutti i carichi di lavoro distribuiti nello spazio dei nomi selezionato.

   Scegli una di queste opzioni e segui i passaggi appropriati:

   • Per annotare un singolo carico di lavoro:

     1. Scegli Annotazione del carico di lavoro.

     2. Incolla una delle seguenti righe nella sezione PodTemplate del file manifesto del carico di lavoro.

        • Per i carichi di lavoro Java: annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • Per i carichi di lavoro Python: annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Per le applicazioni Python, sono necessarie configurazioni aggiuntive. Per ulteriori informazioni, consulta L'applicazione Python non si avvia dopo l'abilitazione di Application Signals.

        • Per i carichi di lavoro .NET annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

          Nota

          Per abilitare Application Signals per un carico di lavoro .NET su immagini basate su Alpine Linux (linux-musl-x64), aggiungi la seguente annotazione.

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

        • Per i carichi di lavoro Node.js: annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. Nel terminale, inserisci kubectl apply -f your_deployment_yaml per applicare la modifica.

   • Per annotare tutti i carichi di lavoro in un namespace:

     1. Scegli Annotazione dello spazio dei nomi.

     2. Incolla una delle seguenti righe nella sezione dei metadati del file manifesto del namespace. Se il namespace include carichi di lavoro Java, Python e .NET, incolla tutte le righe seguenti nel file manifesto del namespace.

        • Se nel namespace sono presenti carichi di lavoro Java: annotations: instrumentation.opentelemetry.io/inject-java: "true"

        • Se nel namespace sono presenti carichi di lavoro Python: annotations: instrumentation.opentelemetry.io/inject-python: "true"

          Per le applicazioni Python, sono necessarie configurazioni aggiuntive. Per ulteriori informazioni, consulta L'applicazione Python non si avvia dopo l'abilitazione di Application Signals.

        • Se nel namespace sono presenti carichi di lavoro .NET: annotations: instrumentation.opentelemetry.io/inject-dotnet: "true"

        • Se nel namespace sono presenti carichi di lavoro Node.JS: annotations: instrumentation.opentelemetry.io/inject-nodejs: "true"

     3. Nel terminale, inserisci kubectl apply -f your_namespace_yaml per applicare la modifica.

     4. Nel tuo terminale, inserisci un comando per riavviare tutti i pod nello spazio dei nomi. Un comando di esempio per riavviare i carichi di lavoro di implementazione è kubectl rollout restart deployment -n namespace_name

7. Scegli Al termine visualizza servizi. Accederai alla visualizzazione dei servizi di Application Signals, dove è possibile visualizzare i dati raccolti da Application Signals. Potrebbero essere necessari alcuni minuti prima che i dati vengano visualizzati.

   Per abilitare Application Signals in un altro cluster Amazon EKS, scegli Abilita Application Signals dalla schermata Servizi.

   Per ulteriori informazioni sulla visualizzazione Servizi, consulta Monitoraggio dell'integrità operativa delle applicazioni con Application Signals.

Per abilitare Application Signals per un'applicazione Node.js con ESM

1. Installa le dipendenze pertinenti nell'applicazione Node.js per l'instrumentazione automatica:

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

2. Aggiungi le seguenti variabili di ambiente al Dockerfile per la tua applicazione e crea l'immagine.

   ...
   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. Aggiungi le variabili di ambiente OTEL_RESOURCE_ATTRIBUTES_POD_NAME, OTEL_RESOURCE_ATTRIBUTES_NODE_NAME, OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME, POD_NAMESPACE e OTEL_RESOURCE_ATTRIBUTES al file yaml di implementazione per l'applicazione. Ad esempio:

   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. Implementa l'applicazione Node.js nel cluster.

1. Abilita Application Signals per le tue applicazioni.

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

   La CloudFormation risorsa Discovery concede ad Application Signals le seguenti autorizzazioni:

   • xray:GetServiceGraph

   • logs:StartQuery

   • logs:GetQueryResults

   • cloudwatch:GetMetricData

   • cloudwatch:ListMetrics

   • tag:GetResources

   Per ulteriori informazioni su questo ruolo, consulta Autorizzazioni di ruolo collegate al servizio per Application Signals CloudWatch .

2. Installa il componente aggiuntivo amazon-cloudwatch-observability.

   1. Crea un ruolo IAM con la CloudWatchAgentServerPolicy e l'OIDC associato al cluster.

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

3. Installa il componente aggiuntivo con il ruolo IAM creato sopra.

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

4. Aggiungi una delle seguenti righe nella sezione PodTemplate del file manifesto del carico di lavoro.

   Lingua	File
   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)