Abilitazione delle applicazioni su Kubernetes

Crea l'utente IAM da utilizzare per fornire le autorizzazioni al tuo host on-premises:

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

2. Scegli Utenti, quindi seleziona Crea utente.

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

4. Nella pagina Imposta autorizzazioni, nel campo Opzioni delle autorizzazioni, scegli Collega direttamente le policy.

5. Dall'elenco Policy di autorizzazione, seleziona la policy CloudWatchAgentServerPolicy da aggiungere all'utente. Quindi scegli Successivo.

6. Nella pagina Rivedi e crea, verifica la correttezza del nome utente e che la policy CloudWatchAgentServerPolicy sia inclusa nel Riepilogo delle autorizzazioni.

7. Scegli Crea utente.

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

1. Nel pannello di navigazione della console IAM, scegli Utenti e 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 Crea chiave di accesso (passaggio 1), scegli Interfaccia a riga di comando (CLI).

4. Per Crea chiave di accesso (passaggio 2), inserisci facoltativamente un tag e scegli Avanti.

5. Per Crea chiave di accesso (passaggio 3), 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 serviranno per i passaggi successivi.

6. Seleziona Fatto.

Configura le credenziali AWS nell'host on-premises immettendo il seguente comando. Sostituisci ACCESS_KEY_ID e SECRET_ACCESS_ID con la chiave di accesso e la chiave di accesso segreta appena generate 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 che l'agente CloudWatch ha installato utilizzando il grafico Helm per aggiungere il segreto delle credenziali AWS appena creato.

kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch

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

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 comandi seguenti. Sostituisci $WORKLOAD_TYPE e $WORKLOAD_NAME con i valori del tuo carico di lavoro.

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

Se il namespace include carichi di lavoro Java, Python e .NET, 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 console CloudWatch, scegli Application Signals, Servizi. Si apriranno i pannelli di controllo nei quali è 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'instrumentazione automatica:

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

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"]

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. 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)"

Implementa l'applicazione Node.js nel cluster Kubernetes.