Abilita Application Signals sulle piattaforme Kubernetes

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

Nel riquadro di navigazione, scegli Servizi.

Scegli Inizia a scoprire i tuoi servizi.

Seleziona la casella di controllo e scegli Inizia a scoprire i tuoi servizi.

Quando completi questo passaggio per la prima volta nel tuo account, Application Signals crea il ruolo AWSServiceRoleForCloudWatchApplicationSignalscollegato al servizio. Questo ruolo concede ad Application Signals le seguenti autorizzazioni:

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

Crea l'IAMutente da utilizzare per fornire le autorizzazioni al tuo host locale:

1. Apri la IAM console all'indirizzo. https://console.aws.amazon.com/iam/

2. Scegli Utenti, Crea utente.

3. In Dettagli utente, in Nome utente, inserisci un nome per il nuovo IAM utente. Questo è il nome di accesso AWS che verrà utilizzato per autenticare il tuo host. quindi scegliere Next.

4. Nella pagina Imposta le autorizzazioni, in Opzioni di autorizzazione, seleziona Allega direttamente le politiche.

5. Dall'elenco delle politiche di autorizzazione, seleziona la CloudWatchAgentServerPolicypolitica da aggiungere al tuo utente. Quindi scegli Successivo.

6. Nella pagina Rivedi e crea, assicurati di essere soddisfatto del nome utente e che la CloudWatchAgentServerPolicypolitica sia inclusa nel riepilogo delle autorizzazioni.

7. Scegli Crea utente

Crea e recupera la tua chiave di AWS accesso e la chiave segreta:

1. Nel riquadro di navigazione della IAM console, scegli Utenti, quindi seleziona il nome utente dell'utente creato nel passaggio precedente.

2. Nella pagina dell'utente, scegli la scheda Credenziali di sicurezza. Quindi, nella sezione Chiavi di accesso, scegli Crea chiave di accesso.

3. Per la creazione della chiave di accesso (Fase 1), scegliete Command Line Interface (CLI).

4. Per la creazione della chiave di accesso (Fase 2), inserite facoltativamente un tag e scegliete Avanti.

5. Per il passaggio 3 della creazione della chiave di accesso, seleziona Scarica il file.csv per salvare un file.csv con la chiave di accesso e la chiave di accesso IAM segreta dell'utente. Queste informazioni sono necessarie per i passaggi successivi.

6. Seleziona Fatto.

Configura AWS le tue credenziali nell'host locale immettendo il seguente comando. Replace (Sostituisci) ACCESS_KEY_ID e SECRET_ACCESS_ID con la chiave di accesso appena generata e la chiave di accesso segreta dal file.csv scaricato nel passaggio precedente. Per impostazione predefinita, il file delle credenziali viene salvato in /home/user/.aws/credentials.

$ aws configure --profile AmazonCloudWatchAgent
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json

Modifica la risorsa personalizzata installata dall' CloudWatch agente utilizzando il grafico Helm per aggiungere il segreto delle AWS credenziali appena creato.

kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch

Mentre l'editor di file è aperto, monta AWS le credenziali nel contenitore dell' CloudWatch agente aggiungendo la seguente configurazione all'inizio della distribuzione. Sostituisci il percorso /home/user/.aws/credentials con la posizione del file delle AWS credenziali locali.

apiVersion: cloudwatch.aws.amazon.com/v1alpha1
kind: AmazonCloudWatchAgent
metadata:
  name: cloudwatch-agent
  namespace: amazon-cloudwatch
spec:
  volumeMounts:
  - mountPath: /rootfs
    volumeMounts:
    - name: aws-credentials
      mountPath: /root/.aws
      readOnly: true
    volumes:
    - hostPath:
      path: /home/user/.aws/credentials
    name: aws-credentials
---

Sono disponibili due opzioni per l'annotazione:

Scegli una di queste opzioni e segui i passaggi appropriati.

Per annotare un singolo carico di lavoro, inserisci uno dei seguenti comandi. Replace (Sostituisci) $WORKLOAD_TYPE e $WORKLOAD_NAME con i valori per il tuo carico di lavoro.

Per annotare tutti i carichi di lavoro in un namespace, inserisci uno dei seguenti comandi. Replace (Sostituisci) $NAMESPACE con il nome del tuo namespace.

Se lo spazio dei nomi include Java, Python e. NETcarichi di lavoro, aggiungi tutte le annotazioni al namespace.

Dopo aver aggiunto le annotazioni, riavvia tutti i pod nel namespace immettendo il seguente comando:

kubectl rollout restart

Una volta completati i passaggi precedenti, nella CloudWatch console, scegli Application Signals, Services. Verranno aperte le dashboard in cui è possibile visualizzare i dati raccolti da Application Signals. Potrebbero essere necessari alcuni minuti prima che i dati vengano visualizzati.

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

Installa le dipendenze pertinenti nell'applicazione Node.js per l'autostrumentazione:

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

Aggiungi le seguenti variabili ambientali 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"]

Aggiungi le variabili ambientaliOTEL_RESOURCE_ATTRIBUTES_POD_NAME, OTEL_RESOURCE_ATTRIBUTES_NODE_NAMEOTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME, POD_NAMESPACE e OTEL_RESOURCE_ATTRIBUTES al file yaml di distribuzione per l'applicazione. Per 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 it 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)"

Distribuisci l'applicazione Node.js nel cluster Kubernetes.