Fase 1: abilitazione di Application Signals nel tuo account Passaggio 2: installa l'operatore dell' CloudWatch agente nel cluster Passaggio 3: configura AWS le credenziali per i tuoi cluster Kubernetes Fase 4: Aggiungere annotazioni (Facoltativo) Fase 5: Monitora lo stato dell'applicazione

Abilita le tue applicazioni su Kubernetes

Abilita CloudWatch Application Signals su Kubernetes utilizzando i passaggi di configurazione personalizzati descritti in questa sezione.

Per le applicazioni in esecuzione su Kubernetes, puoi installare e configurare autonomamente l' CloudWatch agente e Distro. AWS OpenTelemetry Su queste architetture abilitate con una configurazione personalizzata di Application Signals, Application Signals non rileva automaticamente i nomi dei tuoi servizi o dei cluster o host su cui vengono eseguiti. Devi specificare questi nomi durante la configurazione personalizzata e i nomi specificati sono quelli visualizzati nei pannelli di controllo di Application Signals.

Requisiti

Hai l'autorizzazione di amministratore sul cluster Kubernetes in cui stai abilitando Application Signals.
È necessario averlo AWS CLI installato nell'ambiente in cui è in esecuzione il cluster Kubernetes. Per ulteriori informazioni sull'installazione di AWS CLI, consulta Installare o aggiornare la versione più recente di. AWS CLI
Hai kubectl e helm installati sul tuo terminale locale. Per maggiori informazioni, consulta la documentazione di kubectl e Helm.

Fase 1: abilitazione di Application Signals nel tuo account

Devi prima abilitare Application Signals nel tuo account. Se non l'hai fatto, vediAbilita Application Signals nel tuo account.

Passaggio 2: installa l'operatore dell' CloudWatch agente nel cluster

L'installazione dell'operatore CloudWatch agente installa l'operatore, l' CloudWatch agente e altra strumentazione automatica nel cluster. A questo scopo, immetti il comando seguente. Sostituisci con la tua regione$REGION. AWS Sostituiscilo $YOUR_CLUSTER_NAME con il nome che desideri venga visualizzato per il cluster nelle dashboard di Application Signals.


helm repo add aws-observability https://aws-observability.github.io/helm-charts
helm install amazon-cloudwatch-operator aws-observability/amazon-cloudwatch-observability \
--namespace amazon-cloudwatch --create-namespace \
--set region=$REGION \
--set clusterName=$YOUR_CLUSTER_NAME

Per ulteriori informazioni, consulta amazon-cloudwatch-observabilityon. GitHub

Passaggio 3: configura AWS le credenziali per i tuoi cluster Kubernetes

Importante

Se il tuo cluster Kubernetes è ospitato su Amazon EC2, puoi saltare questa sezione e procedere con. Fase 4: Aggiungere annotazioni

Se il tuo cluster Kubernetes è ospitato in locale, devi utilizzare le istruzioni in questa sezione per aggiungere credenziali al tuo ambiente Kubernetes. AWS

Per configurare le autorizzazioni per un cluster Kubernetes locale

Crea l'utente IAM da utilizzare per fornire le autorizzazioni al tuo host locale:
1. Aprire la console IAM 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 utente IAM. 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 console IAM, scegli Utenti, quindi seleziona il nome utente dell'utente che hai 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 Creare la chiave di accesso Step 1, scegli Command Line Interface (CLI).
4. Per la creazione della chiave di accesso (Passaggio 2), inserisci facoltativamente un tag e scegli Avanti.
5. Per la fase 3 di 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 segreta del tuo utente IAM. Queste informazioni ti servono per i passaggi successivi.
6. Seleziona Fatto.
Configura AWS le tue credenziali nell'host locale inserendo il seguente comando. 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
---

Fase 4: Aggiungere annotazioni

Nota

Se state abilitando Application Signals per un'applicazione Node.js con ESM, saltate i passaggi di questa sezione e guardate invece. Configurazione di un'applicazione Node.js con il formato del modulo ESM

Il passaggio successivo consiste nello strumentare l' CloudWatch applicazione per Application Signals aggiungendo un'annotazione specifica della lingua al carico di lavoro o allo spazio dei nomi Kubernetes. Questa annotazione strumenta automaticamente la tua applicazione per inviare metriche, tracce e log a Application Signals.

Per aggiungere le annotazioni per Application Signals

Sono disponibili due opzioni per l'annotazione:
- Annotate Workload organizza automaticamente un singolo carico di lavoro in un 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, inserisci uno dei seguenti comandi. Sostituisci $WORKLOAD_TYPE e $WORKLOAD_NAME con i valori per il tuo carico di lavoro.

Per i carichi di lavoro Java:


kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-java": "true"}}}}}'

Per i carichi di lavoro Python:
```
kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"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'attivazione di Application Signals.

Per i carichi di lavoro.NET:


kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"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 aggiuntiva.


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

Per i carichi di lavoro Node.js:


kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-nodejs": "true"}}}}}'

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

Se lo spazio dei nomi include carichi di lavoro Java, Python e.NET, aggiungi tutte le annotazioni allo spazio dei nomi.
- Per i carichi di lavoro Java nello spazio dei nomi:
```
kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-java=true
```
- Per i carichi di lavoro Python nel namespace:
```
kubectl annotate ns $NAMESPACE 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'attivazione di Application Signals.
- Per i carichi di lavoro.NET nello spazio dei nomi:
```
kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-dotnet=true
```
- Per i carichi di lavoro Node.js nello spazio dei nomi:
```
kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-nodejs=true
```
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.

Configurazione di un'applicazione Node.js con il formato del modulo ESM

Forniamo un supporto limitato per le applicazioni Node.js con il formato del modulo ESM. Per informazioni dettagliate, consultare Limitazioni note relative a Node.js con ESM.

Per il formato del modulo ESM, l'abilitazione di Application Signals mediante l'annotazione del file manifest non funziona. Saltate la procedura precedente ed effettuate invece quanto segue:

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

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.

(Facoltativo) Fase 5: Monitora lo stato dell'applicazione

Dopo aver abilitato le applicazioni su Kubernetes, puoi monitorare lo stato delle applicazioni. Per ulteriori informazioni, consulta Monitoraggio dell'integrità operativa delle applicazioni con Application Signals.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Abilita Application Signals su Amazon ECS utilizzando AWS CDK

Abilita le tue applicazioni su Lambda