Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Abilitazione delle 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** + Devi disporre dell'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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) di. AWS CLI + Sul terminale locale devono essere installati kubectl e helm. Per ulteriori informazioni, consulta la documentazione di [ kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl) e [ Helm](https://helm.sh/) . ## Passaggio 1: abilitazione di Application Signals nell'account Prima devi abilitare Application Signals nel tuo account. Se non lo hai ancora fatto, consulta [Abilitazione di Application Signals in un account](CloudWatch-Application-Signals-Enable.md). ## 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-observability](https://github.com/aws-observability/helm-charts/tree/main/charts/amazon-cloudwatch-observability)on. GitHub ## Passaggio 3: configura AWS le credenziali per i tuoi cluster Kubernetes **Importante** Se il tuo cluster Kubernetes è ospitato su Amazon EC2, puoi ignorare questa sezione e passare a [Passaggio 4: aggiunta di annotazioni](#Application-Signals-Enable-Kubernetes-annotations). Se il cluster Kubernetes è ospitato in locale, è necessario utilizzare le istruzioni in questa sezione per aggiungere credenziali all'ambiente Kubernetes. AWS **Per impostare le autorizzazioni per un cluster Kubernetes on-premises** 1. 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/](https://console.aws.amazon.com/iam/). 1. Scegli **Utenti**, quindi seleziona **Crea utente**. 1. 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 l'host. quindi scegliere **Next**. 1. Nella pagina **Imposta autorizzazioni**, nel campo **Opzioni delle autorizzazioni**, scegli **Collega direttamente le policy**. 1. Dall'elenco delle **politiche di autorizzazione**, seleziona la **CloudWatchAgentServerPolicy**politica da aggiungere al tuo utente. Quindi scegli **Successivo**. 1. Nella pagina **Rivedi e crea**, assicurati di essere soddisfatto del nome utente e che la **CloudWatchAgentServerPolicy**politica sia inclusa nel riepilogo delle **autorizzazioni**. 1. Scegli **Crea utente**. 1. 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. 1. Nella pagina dell'utente, scegli la scheda **Credenziali di sicurezza**. Quindi, nella sezione **Chiavi di accesso**, scegli **Crea chiave di accesso**. 1. Per **Crea chiave di accesso (passaggio 1)**, scegli **Interfaccia a riga di comando (CLI)**. 1. Per **Crea chiave di accesso (passaggio 2)**, inserisci facoltativamente un tag e scegli **Avanti**. 1. 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. 1. Seleziona **Fatto**. 1. 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 ``` 1. Modifica la risorsa personalizzata installata dall' CloudWatch agente utilizzando il grafico Helm per aggiungere il segreto delle credenziali appena creato AWS . ``` kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch ``` 1. 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 --- ``` ## Passaggio 4: aggiunta di annotazioni **Nota** Se stai abilitando Application Signals per un'applicazione Node.js con ESM, salta questa sezione e vai invece a [Configurazione di un'applicazione Node.js con il formato del modulo ESM](#Kubernetes-NodeJs-ESM). [https://kubernetes.io/docs/concepts/workloads/](https://kubernetes.io/docs/concepts/workloads/) L'aggiunta di questa annotazione instrumenta automaticamente l'applicazione per inviare metriche, tracce e log ad Application Signals. **Per aggiungere le annotazioni per Application Signals** 1. Sono disponibili due opzioni per l'annotazione: + L'**annotazione del carico di lavoro** instrumenta automaticamente un singolo carico di lavoro nel cluster. + L'**annotazione del namespace** instrumenta automaticamente tutti i carichi di lavoro implementati nel namespace selezionato. Scegli una di queste opzioni e segui i passaggi appropriati. 1. Per annotare un singolo carico di lavoro, inserisci uno dei comandi seguenti. {{$WORKLOAD\_TYPE}}{{$WORKLOAD\_NAME}}Sostituisci e 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'abilitazione di Application Signals](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python). + 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 ulteriore. ``` 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"}}}}}' ``` 1. 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. + Per i carichi di lavoro Java nel namespace: ``` 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'abilitazione di Application Signals](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python). + Per i carichi di lavoro .NET nel namespace: ``` kubectl annotate ns {{$NAMESPACE}} instrumentation.opentelemetry.io/inject-dotnet=true ``` + Per i carichi di lavoro Node.js nel namespace: ``` 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 ``` 1. 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](Services.md). ### 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, vedi [Limitazioni note di Node.js con ESM](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations). Per il formato del modulo ESM, l'abilitazione di Application Signals tramite l'annotazione del file manifesto non funziona. Salta la procedura precedente ed esegui invece quanto segue: **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 ``` 1. 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"] ``` 1. 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. 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)" ``` 1. Implementa l'applicazione Node.js nel cluster Kubernetes. ## (Facoltativo) Passaggio 5: monitoraggio dell'integrità delle applicazioni Dopo aver abilitato le applicazioni su Kubernetes, è possibile monitorarne l'integrità. Per ulteriori informazioni, consulta [Monitoraggio dell'integrità operativa delle applicazioni con Application Signals](Services.md).