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 che verrà utilizzato per AWS 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 delle politiche di autorizzazione, seleziona la CloudWatchAgentServerPolicy politica da aggiungere al tuo utente. Quindi scegli Successivo.

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

7. Scegli Crea utente.

Crea e recupera la tua chiave di AWS accesso 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 AWS le tue credenziali nel tuo 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 le credenziali segrete appena create AWS .

kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch

Mentre l'editor di file è aperto, monta AWS le credenziali nel contenitore CloudWatch dell'agente aggiungendo la seguente configurazione nella parte superiore 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 comandi seguenti. $WORKLOAD_TYPE$WORKLOAD_NAMESostituisci e con i valori per il 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 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 CloudWatch console, scegli Application Signals, Services. 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 alla tua Node.js applicazione per la strumentazione 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. 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 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' Node.js applicazione nel cluster Kubernetes.