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à.
# Configurazione di Container Insights
Il processo di configurazione di Container Insights è diverso per Amazon ECS, per Amazon EKS e per Kubernetes.
+ [Configurazione di Container Insights su Amazon EKS e Kubernetes](deploy-container-insights-EKS.md)
+ [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md)
**Topics**
+ [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md)
+ [Configurazione di Container Insights su Amazon EKS e Kubernetes](deploy-container-insights-EKS.md)
+ [Configurazione di Container Insights su on RedHat OpenShift (ROSA) AWS](deploy-container-insights-RedHatOpenShift.md)
# Configurazione di Container Insights su Amazon ECS
Puoi utilizzare una o entrambe le opzioni seguenti per abilitare Container Insights su cluster di Amazon ECS:
+ Usa Console di gestione AWS o the AWS CLI per iniziare a raccogliere metriche a livello di cluster, a livello di attività e a livello di servizio.
+ Implementa l' CloudWatch agente come servizio daemon per iniziare a raccogliere parametri a livello di istanza sui cluster ospitati su istanze Amazon EC2.
**Topics**
+ [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS-cluster.md)
+ [Configurazione di Container Insights su Amazon ECS utilizzando AWS Distro per OpenTelemetry](deploy-container-insights-ECS-adot.md)
+ [Implementazione dell' CloudWatch agente per raccogliere parametri a livello di istanza EC2 su Amazon ECS](deploy-container-insights-ECS-instancelevel.md)
+ [Implementazione della AWS distribuzione per raccogliere parametri OpenTelemetry a livello di istanza EC2 sui cluster Amazon ECS](deploy-container-insights-ECS-OTEL.md)
+ [Configurazione FireLens per l'invio di log a CloudWatch Logs](deploy-container-insights-ECS-logs.md)
# Configurazione di Container Insights su Amazon ECS
Puoi configurare Container Insights con osservabilità migliorata o Container Insights su cluster Amazon ECS nuovi ed esistenti utilizzando la console Amazon ECS o la AWS CLI. Container Insights raccoglie i parametri a livello di cluster, attività e servizio. Container Insights con osservabilità migliorata fornisce dimensioni e metriche aggiuntive, consentendoti di approfondire l'analisi fino a una visibilità a livello di container.
Se utilizzi Amazon ECS su un'istanza Amazon EC2, avvia l'istanza utilizzando un'AMI che include l'agente Amazon ECS versione 1.29 o successive. Per informazioni su come aggiornare la versione dell'agente, consulta [Aggiornamento dell'agente del container di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
**Nota**
Se la AWS KMS chiave gestita dal cliente che utilizzi per i parametri di Amazon ECS Container Insights non è già configurata per funzionare CloudWatch, devi aggiornare la policy delle chiavi per consentire i log crittografati nei log. CloudWatch È inoltre necessario associare la propria AWS KMS chiave al gruppo di log in. `/aws/ecs/containerinsights/ClusterName/performance` Per ulteriori informazioni, [consulta Crittografare i dati di registro in CloudWatch Logs using. AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html)
Ti consigliamo di utilizzare Container Insights con osservabilità avanzata invece di Container Insights in quanto fornisce una visibilità dettagliata nell’ambiente del container, riducendo il tempo medio di risoluzione.
## Impostazione di Container Insights con osservabilità migliorata
Puoi attivare Container Insights con osservabilità migliorata utilizzando la console Amazon ECS o la AWS CLI.
------
#### [ AWS CLI ]
Utilizza il comando seguente per attivare Container Insights con osservabilità migliorata.
Configura l'impostazione dell'account `containerInsights` su `enhanced`
```
aws ecs put-account-setting --name containerInsights --value enhanced
```
Output di esempio
```
{
"setting": {
"name": "containerInsights",
"value": "enhanced",
"principalArn": "arn:aws:iam::123456789012:johndoe",
"type": user
}
}
```
**Nota**
Per impostazione predefinita, `put-account-setting` si applica solo all'utente attualmente autenticato. Per abilitare l'impostazione a livello di account per tutti gli utenti e i ruoli, utilizza l'utente root come nell'esempio seguente.
```
aws ecs put-account-setting --name containerInsights --value enhanced --principal-arn arn:aws:iam::accountID:root
```
Dopo aver configurato questa impostazione dell'account, tutti i nuovi cluster utilizzano automaticamente Container Insights con osservabilità migliorata. Usa il comando `update-cluster-settings` per aggiungere Container Insights con osservabilità migliorata al cluster esistente o per aggiornare i cluster che attualmente utilizzano Container Insights a Container Insights con osservabilità migliorata.
```
aws ecs update-cluster-settings --cluster cluster-name --settings name=containerInsights,value=enhanced
```
------
#### [ Amazon ECS console ]
1. [Apri la console alla v2. https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/v2)
1. Nella barra di navigazione nella parte superiore, seleziona la Regione per la quale visualizzare le impostazioni dell'account.
1. Nel riquadro di navigazione, scegli **Account Settings** (Impostazioni account).
1. Scegliere **Aggiorna**.
1. Per utilizzare Container Insights con osservabilità migliorata, scegli **Container Insights con osservabilità migliorata**.
1. Scegli **Save changes** (Salva modifiche).
1. Nella schermata di conferma, scegliere **Conferma** per salvare la selezione.
Dopo aver configurato questa impostazione, tutti i nuovi cluster utilizzano automaticamente Container Insights con osservabilità migliorata. Puoi aggiungere Container Insights con osservabilità migliorata ai cluster esistenti o aggiornare i cluster che attualmente utilizzano Container Insights a Container Insights con osservabilità migliorata. Per ulteriori informazioni, consulta [Aggiornamento di un cluster Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-cluster-v2.html) nella *Guida per gli sviluppatori di Amazon Elastic Container Service*.
------
## Configurazione di Container Insights
Puoi attivare Container Insights utilizzando la console Amazon ECS o la AWS CLI.
------
#### [ AWS CLI ]
Per utilizzare Container Insights, configura l'impostazione dell'account `container Insights` su `enabled`. Utilizza il comando seguente per attivare Container Insights.
```
aws ecs put-account-setting --name containerInsights --value enabled
```
Output di esempio
```
{
"setting": {
"name": "container Insights",
"value": "enabled",
"principalArn": "arn:aws:iam::123456789012:johndoe",
"type": user
}
}
```
Quando configuri l'impostazione dell'account `container Insights` su `enabled`, tutti i nuovi cluster hanno Container Insights abilitato per impostazione predefinita. Usa il comando `update-cluster-settings` per aggiungere Container Insights a un cluster esistente.
```
aws ecs update-cluster-settings --cluster cluster-name --settings name=containerInsights,value=enabled
```
------
#### [ Amazon ECS console ]
1. Apri la console nella [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Nella barra di navigazione nella parte superiore, seleziona la Regione per la quale visualizzare le impostazioni dell'account.
1. Nel riquadro di navigazione, scegli **Account Settings** (Impostazioni account).
1. Scegliere **Aggiorna**.
1. Per utilizzare Container Insights scegli **Container Insights**.
1. Scegli **Save changes** (Salva modifiche).
1. Nella schermata di conferma, scegliere **Conferma** per salvare la selezione.
Dopo aver configurato questa impostazione, tutti i nuovi cluster utilizzano automaticamente Container Insights. Aggiorna i cluster esistenti per aggiungere Container Insights. Per ulteriori informazioni, consulta [Aggiornamento di un cluster Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-cluster-v2.html) nella *Guida per gli sviluppatori di Amazon Elastic Container Service*.
------
# Configurazione di Container Insights su Amazon ECS utilizzando AWS Distro per OpenTelemetry
Utilizza questa sezione se desideri utilizzare AWS Distro OpenTelemetry per configurare CloudWatch Container Insights su un cluster Amazon ECS. [Per ulteriori informazioni su AWS Distro for Open Telemetry, consulta Distro for.AWS OpenTelemetry](https://aws.amazon.com/otel/)
In queste fasi si presuppone che tu disponga già di un cluster su Amazon ECS. Per ulteriori informazioni sull'utilizzo di AWS Distro for Open Telemetry con Amazon ECS e sulla configurazione di un cluster Amazon ECS per questo scopo, [consulta Configurazione di AWS Distro for OpenTelemetry Collector](https://aws-otel.github.io/docs/setup/ecs) in Amazon Elastic Container Service.
## Fase 1: creazione di un ruolo dell'attività
Il primo passaggio consiste nella creazione di un ruolo di attività nel cluster che verrà utilizzato da Collector. AWS OpenTelemetry
**Creare un ruolo di attività per AWS Distro per OpenTelemetry**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione, seleziona **Policy** e **Crea policy**.
1. Scegli la scheda **JSON** e copia la policy seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:DescribeLogGroups",
"ssm:GetParameters"
],
"Resource": "*"
}
]
}
```
------
1. Scegliere **Esamina policy**.
1. Nel campo Name (Nome), inserisci **AWSDistroOpenTelemetryPolicy**, quindi scegli **Create policy** (Crea policy).
1. Nel pannello di navigazione sinistro, scegli **Roles** (Ruoli), quindi **Create role** (Crea ruolo).
1. Nell'elenco dei servizi, scegli **Elastic Container Service**.
1. In basso nella pagina, scegli **Elastic Container Service Task** (Attività di Elastic Container Service) e quindi **Next: Permissions** (Avanti: autorizzazioni).
1. Nell'elenco delle politiche, cerca **AWSDistroOpenTelemetryPolicy**.
1. Seleziona la casella di controllo accanto a **AWSDistroOpenTelemetryPolicy**.
1. Scegli **Next: Tags** (Successivo: Tag), quindi **Next: Review** (Successivo: Verifica).
1. In **Role name** (Nome ruolo) inserisci **AWSOpenTelemetryTaskRole** e quindi seleziona **Create role** (Crea ruolo).
## Fase 2: creazione di un ruolo di esecuzione dell'attività
Il passaggio successivo consiste nella creazione di un ruolo di esecuzione delle attività per il AWS OpenTelemetry Collector.
**Creare un ruolo di esecuzione delle attività per AWS Distro for OpenTelemetry**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione sinistro, scegli **Roles** (Ruoli), quindi **Create role** (Crea ruolo).
1. Nell'elenco dei servizi, scegli **Elastic Container Service**.
1. In basso nella pagina, scegli **Elastic Container Service Task** (Attività di Elastic Container Service) e quindi **Next: Permissions** (Avanti: autorizzazioni).
1. Nell'elenco delle politiche, cerca **Amazon ECSTask ExecutionRolePolicy** e seleziona la casella di controllo accanto ad **Amazon ECSTask ExecutionRolePolicy**.
1. Nell'elenco delle politiche, cerca **CloudWatchLogsFullAccess**e seleziona la casella di controllo accanto a **CloudWatchLogsFullAccess**.
1. Nell'elenco delle politiche, cerca **Amazon SSMRead OnlyAccess** e seleziona la casella di controllo accanto ad **Amazon SSMRead OnlyAccess**.
1. Scegli **Next: Tags** (Successivo: Tag), quindi **Next: Review** (Successivo: Verifica).
1. In **Role name** (Nome ruolo) inserisci **AWSOpenTelemetryTaskExecutionRole** e quindi seleziona **Create role** (Crea ruolo).
## Fase 3: creazione di una definizione di attività
La fase successiva consiste nella creazione di una definizione di attività.
**Per creare una definizione di attività per AWS Distro for OpenTelemetry**
1. [Apri la console nella versione 2https://console.aws.amazon.com/ecs/.](https://console.aws.amazon.com/ecs/v2)
1. Nel pannello di navigazione, scegli **Task Definitions** (Definizioni di attività).
1. Scegli **Create new task definitions** (Crea nuova definizione di attività) e **Create new Task Definition** (Crea nuova definizione attività).
1. Per **Task definition family** (Famiglia della definizione di attività) specifica un nome univoco per la definizione di attività.
1. Configura i tuoi container, quindi scegli **Successivo**.
1. In **Parametri e registrazione**, seleziona **Usa raccolta di parametri**.
1. Scegli **Next (Successivo)**.
1. Scegli **Create** (Crea).
Per ulteriori informazioni sull'utilizzo del AWS OpenTelemetry collector con Amazon ECS, consulta [Configurazione di AWS Distro for OpenTelemetry Collector in Amazon](https://aws-otel.github.io/docs/setup/ecs) Elastic Container Service.
## Fase 4: esecuzione dell'attività
La fase finale consiste nell'esecuzione dell'attività creata.
**Per eseguire l'attività per Distro per AWS OpenTelemetry**
1. [Apri la console nella versione 2https://console.aws.amazon.com/ecs/.](https://console.aws.amazon.com/ecs/v2)
1. Nel pannello di navigazione sinistro, scegli **Task Definitions** (Definizioni di attività), quindi seleziona l'attività appena creata.
1. Scegli **Operazioni**, **Implementa**, **Esegui attività**.
1. Scegli **Deploy** (Implementa), **Run task** (Esegui processo).
1. Nella sezione **Opzioni di calcolo**, da **Cluster esistente**, scegli il cluster.
1. Scegli **Create** (Crea).
1. Successivamente, puoi verificare le nuove metriche nella CloudWatch console.
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione a sinistra scegli **Metrics** (Parametri).
Dovresti vedere uno spazio dei nomi **ECS/ ContainerInsights**. Scegli lo spazio dei nomi, dovresti vedere otto parametri.
# Implementazione dell' CloudWatch agente per raccogliere parametri a livello di istanza EC2 su Amazon ECS
Per distribuire l' CloudWatch agente per raccogliere parametri a livello di istanza dai cluster Amazon ECS ospitati su un'istanza EC2, utilizza una configurazione di avvio rapido con una configurazione predefinita o installa l'agente manualmente per poterlo personalizzare.
Entrambi i metodi richiedono che tu disponga già di almeno un cluster Amazon ECS distribuito con un tipo di avvio EC2 e che il contenitore dell' CloudWatch agente abbia accesso all'Amazon EC2 Instance Metadata Service (IMDS). Per ulteriori informazioni su IMDS, consulta [Metadati dell'istanza e dati utente](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html).
Questi metodi presuppongono inoltre che tu abbia installato il. AWS CLI Inoltre, per eseguire i comandi nelle procedure seguenti, devi accedere a un account o ruolo con le politiche **IAMFullAccess** e **FullAccessAmazoneCS\$1**.
**Importante**
Quando definisci il contenitore dell' CloudWatch agente nella definizione dell'attività, imposta. `essential: false` Ciò impedisce l'interruzione dell'intero servizio Amazon ECS in caso di guasto del contenitore CloudWatch Agent. Anche se l'agente è temporaneamente non disponibile, altri container di applicazioni critiche continueranno a funzionare.
**Topics**
+ [Configurazione rapida utilizzando CloudFormation](#deploy-container-insights-ECS-instancelevel-quickstart)
+ [Configurazione manuale e personalizzata](#deploy-container-insights-ECS-instancelevel-manual)
## Configurazione rapida utilizzando CloudFormation
Per utilizzare la configurazione rapida, inserisci il seguente comando da utilizzare per installare l'agente. CloudFormation Sostituisci *cluster-name* e *cluster-region* con il nome e la regione del tuo cluster Amazon ECS.
Questo comando crea i ruoli IAM **CWAgentECSTaskRole** e **CWAgentECSExecutionRole**. Se questi ruoli esistono già nell'account, utilizza `ParameterKey=CreateIAMRoles,ParameterValue=False` anziché `ParameterKey=CreateIAMRoles,ParameterValue=True` quando immetti il comando. In caso contrario, il comando avrà esito negativo.
```
ClusterName=cluster-name
Region=cluster-region
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/daemon-service/cwagent-ecs-instance-metric/cloudformation-quickstart/cwagent-ecs-instance-metric-cfn.json
aws cloudformation create-stack --stack-name CWAgentECS-${ClusterName}-${Region} \
--template-body file://cwagent-ecs-instance-metric-cfn.json \
--parameters ParameterKey=ClusterName,ParameterValue=${ClusterName} \
ParameterKey=CreateIAMRoles,ParameterValue=True \
--capabilities CAPABILITY_NAMED_IAM \
--region ${Region}
```
**(Alternativa) Utilizzo dei propri ruoli IAM**
Se desideri utilizzare il tuo ruolo di attività ECS personalizzato e il tuo ruolo di esecuzione dell'attività ECS anziché i ruoli **CWAgentECSTaskRuolo** e **CWAgentECSExecutionRuolo**, assicurati innanzitutto che il ruolo da utilizzare come ruolo di attività ECS sia associato. **CloudWatchAgentServerPolicy** Inoltre, assicurati che al ruolo da utilizzare come ruolo di esecuzione delle attività ECS siano associate **CloudWatchAgentServerPolicy**sia le ECSTask ExecutionRolePolicy policy che quelle di **Amazon**. Quindi, immetti il comando seguente: Nel comando, sostituisci *task-role-arn* con l'ARN del tuo ruolo di attività ECS personalizzato e sostituiscilo con *execution-role-arn* l'ARN del tuo ruolo di esecuzione dell'attività ECS personalizzato.
```
ClusterName=cluster-name
Region=cluster-region
TaskRoleArn=task-role-arn
ExecutionRoleArn=execution-role-arn
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/daemon-service/cwagent-ecs-instance-metric/cloudformation-quickstart/cwagent-ecs-instance-metric-cfn.json
aws cloudformation create-stack --stack-name CWAgentECS-${ClusterName}-${Region} \
--template-body file://cwagent-ecs-instance-metric-cfn.json \
--parameters ParameterKey=ClusterName,ParameterValue=${ClusterName} \
ParameterKey=TaskRoleArn,ParameterValue=${TaskRoleArn} \
ParameterKey=ExecutionRoleArn,ParameterValue=${ExecutionRoleArn} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${Region}
```
**Risoluzione dei problemi relativi alla configurazione rapida**
Per verificare lo stato dello CloudFormation stack, inserisci il seguente comando.
```
ClusterName=cluster-name
Region=cluster-region
aws cloudformation describe-stacks --stack-name CWAgentECS-$ClusterName-$Region --region $Region
```
Se `StackStatus` è diverso da `CREATE_COMPLETE` o `CREATE_IN_PROGRESS`, controlla gli eventi di stack per trovare l'errore. Inserire il seguente comando.
```
ClusterName=cluster-name
Region=cluster-region
aws cloudformation describe-stack-events --stack-name CWAgentECS-$ClusterName-$Region --region $Region
```
Per verificare lo stato del servizio daemon `cwagent`, immetti il seguente comando. Nell'output, deve essere mostrato che `runningCount` è uguale a `desiredCount` nella sezione `deployment`. In caso contrario, controlla la sezione `failures` nell'output.
```
ClusterName=cluster-name
Region=cluster-region
aws ecs describe-services --services cwagent-daemon-service --cluster $ClusterName --region $Region
```
Puoi anche utilizzare la console CloudWatch Logs per controllare il registro dell'agente. Cerca il gruppo di log **ecs-cwagent-daemon-service/ecs/.**
**Eliminazione dello stack per l'agente CloudFormation CloudWatch **
Se è necessario eliminare lo CloudFormation stack, immettere il seguente comando.
```
ClusterName=cluster-name
Region=cluster-region
aws cloudformation delete-stack --stack-name CWAgentECS-${ClusterName}-${Region} --region ${Region}
```
## Configurazione manuale e personalizzata
Segui i passaggi in questa sezione per distribuire manualmente l' CloudWatch agente per raccogliere parametri a livello di istanza dai tuoi cluster Amazon ECS ospitati su istanze EC2.
### Ruoli e policy IAM necessari
Sono richiesti due ruoli IAM. Se non esistono già è necessario crearli. Per ulteriori informazioni su questi ruoli, consulta [Ruoli IAM per attività](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) e [Ruolo per l'esecuzione di attività Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html).
+ Un *ruolo di attività ECS*, utilizzato dall'agente per pubblicare le metriche. CloudWatch Se questo ruolo esiste già, è necessario assicurarsi che ad esso sia collegata la policy `CloudWatchAgentServerPolicy`.
+ Un *ruolo di esecuzione delle attività ECS*, utilizzato dall'agente Amazon ECS per avviare l' CloudWatch agente. Se questo ruolo esiste già, è necessario assicurarsi che le policy `AmazonECSTaskExecutionRolePolicy` e `CloudWatchAgentServerPolicy` siano collegate ad esso.
Se questi ruoli non sono ancora disponibili, puoi utilizzare i seguenti comandi per crearli e collegare le policy necessarie. Questo primo comando crea il ruolo attività ECS.
```
aws iam create-role --role-name CWAgentECSTaskRole \
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Sid\": \"\",\"Effect\": \"Allow\",\"Principal\": {\"Service\": \"ecs-tasks.amazonaws.com\"},\"Action\": \"sts:AssumeRole\"}]}"
```
Dopo aver immesso il comando precedente, annota il valore dell'output `Arn` del comando come "»TaskRoleArn. Questo sarà richiesto in seguito durante la creazione della definizione di attività. Quindi immetti il seguente comando per collegare le policy necessarie.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--role-name CWAgentECSTaskRole
```
Questo comando successivo crea il ruolo per l'esecuzione di attività ECS.
```
aws iam create-role --role-name CWAgentECSExecutionRole \
--assume-role-policy-document "{\"Version\": \"2012-10-17\", \"Statement\": [{\"Sid\": \"\",\"Effect\": \"Allow\",\"Principal\": {\"Service\": \"ecs-tasks.amazonaws.com\"},\"Action\": \"sts:AssumeRole\"}]}"
```
Dopo aver immesso il comando precedente, annotate il valore `Arn` dell'output del comando come "ExecutionRoleArn». Questo sarà richiesto in seguito durante la creazione della definizione di attività. Quindi immetti i seguenti comandi per collegare le policy necessarie.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--role-name CWAgentECSExecutionRole
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy \
--role-name CWAgentECSExecutionRole
```
### Creazione della definizione di attività e avvio del servizio Daemon
Crea una definizione di attività e usala per avviare l'agente come servizio daemon. CloudWatch Per creare la definizione di attività, immetti il seguente comando. Nelle prime righe, sostituisci i segnaposto con i valori effettivi per la distribuzione. *logs-region*è la regione in cui si trova CloudWatch Logs ed *cluster-region* è la regione in cui si trova il cluster. *task-role-arn*è l'Arn del ruolo dell'attività ECS che si sta utilizzando ed *execution-role-arn* è l'Arn del ruolo di esecuzione dell'attività ECS.
```
TaskRoleArn=task-role-arn
ExecutionRoleArn=execution-role-arn
AWSLogsRegion=logs-region
Region=cluster-region
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/daemon-service/cwagent-ecs-instance-metric/cwagent-ecs-instance-metric.json \
| sed "s|{{task-role-arn}}|${TaskRoleArn}|;s|{{execution-role-arn}}|${ExecutionRoleArn}|;s|{{awslogs-region}}|${AWSLogsRegion}|" \
| xargs -0 aws ecs register-task-definition --region ${Region} --cli-input-json
```
Quindi esegui il seguente comando per avviare il servizio daemon. Sostituisci *cluster-name* e *cluster-region* con il nome e la regione del tuo cluster Amazon ECS.
**Importante**
Rimuovi tutte le strategie dei provider di capacità prima di eseguire questo comando. In caso contrario, il comando non funzionerà.
```
ClusterName=cluster-name
Region=cluster-region
aws ecs create-service \
--cluster ${ClusterName} \
--service-name cwagent-daemon-service \
--task-definition ecs-cwagent-daemon-service \
--scheduling-strategy DAEMON \
--region ${Region}
```
Se viene visualizzato questo messaggio di errore, `An error occurred (InvalidParameterException) when calling the CreateService operation: Creation of service was not idempotent`, un servizio daemon denominato `cwagent-daemon-service` è già stato creato. Elimina innanzitutto tale servizio, utilizzando il comando riportato di seguito come un esempio.
```
ClusterName=cluster-name
Region=cluster-region
aws ecs delete-service \
--cluster ${ClusterName} \
--service cwagent-daemon-service \
--region ${Region} \
--force
```
### (Facoltativo) Configurazione avanzata
Facoltativamente, puoi utilizzare SSM per specificare altre opzioni di configurazione per l' CloudWatchagente nei tuoi cluster Amazon ECS ospitati su istanze EC2. Le opzioni sono le seguenti:
+ `metrics_collection_interval`— Con quale frequenza, in secondi, l'agente raccoglie i parametri. CloudWatch Il valore predefinito è 60. L'intervallo varia tra 1 e 172.000.
+ `endpoint_override` (Facoltativo): specifica un endpoint diverso a cui inviare i log. Potrebbe essere richiesto se si sta pubblicando da un cluster in un VPC e si desidera inviare i dati di log a un endpoint VPC.
Il valore di `endpoint_override` deve essere una stringa che è un URL.
+ `force_flush_interval`: specifica in secondi la quantità massima di tempo in cui i log rimangono nel buffer di memoria prima di essere inviati al server. Indipendentemente dall'impostazione di questo campo, se la dimensione dei log nel buffer raggiunge 1 MB, i log vengono immediatamente inviati al server. Il valore predefinito è 5 secondi.
+ `region`: per impostazione predefinita, l'agente pubblica i parametri nella stessa regione in cui si trova l'istanza di container Amazon ECS. Per sovrascriverla, è possibile specificare una regione diversa qui. Ad esempio, `"region" : "us-east-1"`
Di seguito è riportato un esempio di configurazione personalizzata:
```
{
"agent": {
"region": "us-east-1"
},
"logs": {
"metrics_collected": {
"ecs": {
"metrics_collection_interval": 30
}
},
"force_flush_interval": 5
}
}
```
**Per personalizzare la configurazione degli CloudWatch agenti nei contenitori Amazon ECS**
1. Assicurati che la SSMRead OnlyAccess policy di **Amazon** sia associata al tuo ruolo di Amazon ECS Task Execution. A questo scopo, è possibile immettere il seguente comando. Questo esempio presuppone che il ruolo di Amazon ECS Task Execution sia CWAgent ECSExecution Role. Se utilizzi un ruolo diverso, sostituire tale nome del ruolo nel comando seguente.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess \
--role-name CWAgentECSExecutionRole
```
1. Creare il file di configurazione personalizzato simile all'esempio precedente. Assegnare a questo file il nome `/tmp/ecs-cwagent-daemon-config.json`.
1. Eseguire il seguente comando per inserire questa configurazione nel Parameter Store. Sostituisci *cluster-region* con la regione del tuo cluster Amazon ECS. Per eseguire questo comando, devi accedere a un utente o a un ruolo con la politica di **Amazon SSMFull Access**.
```
Region=cluster-region
aws ssm put-parameter \
--name "ecs-cwagent-daemon-service" \
--type "String" \
--value "`cat /tmp/ecs-cwagent-daemon-config.json`" \
--region $Region
```
1. Scaricare il file di definizione dell'attività in un file locale, ad esempio `/tmp/cwagent-ecs-instance-metric.json`
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/daemon-service/cwagent-ecs-instance-metric/cwagent-ecs-instance-metric.json -o /tmp/cwagent-ecs-instance-metric.json
```
1. Modificare il file di definizione dell'attività. Rimuovere la sezione seguente:
```
"environment": [
{
"name": "USE_DEFAULT_CONFIG",
"value": "True"
}
],
```
Sostituire tale sezione con la seguente:
```
"secrets": [
{
"name": "CW_CONFIG_CONTENT",
"valueFrom": "ecs-cwagent-daemon-service"
}
],
```
1. Riavviare l'agente come servizio daemon effettuando la seguente procedura:
1. Eseguire il seguente comando seguente.
```
TaskRoleArn=task-role-arn
ExecutionRoleArn=execution-role-arn
AWSLogsRegion=logs-region
Region=cluster-region
cat /tmp/cwagent-ecs-instance-metric.json \
| sed "s|{{task-role-arn}}|${TaskRoleArn}|;s|{{execution-role-arn}}|${ExecutionRoleArn}|;s|{{awslogs-region}}|${AWSLogsRegion}|" \
| xargs -0 aws ecs register-task-definition --region ${Region} --cli-input-json
```
1. Eseguire il comando seguente per avviare il servizio daemon. Sostituisci *cluster-name* e *cluster-region* con il nome e la regione del tuo cluster Amazon ECS.
```
ClusterName=cluster-name
Region=cluster-region
aws ecs create-service \
--cluster ${ClusterName} \
--service-name cwagent-daemon-service \
--task-definition ecs-cwagent-daemon-service \
--scheduling-strategy DAEMON \
--region ${Region}
```
Se viene visualizzato questo messaggio di errore, `An error occurred (InvalidParameterException) when calling the CreateService operation: Creation of service was not idempotent`, un servizio daemon denominato `cwagent-daemon-service` è già stato creato. Elimina innanzitutto tale servizio, utilizzando il comando riportato di seguito come un esempio.
```
ClusterName=cluster-name
Region=Region
aws ecs delete-service \
--cluster ${ClusterName} \
--service cwagent-daemon-service \
--region ${Region} \
--force
```
# Implementazione della AWS distribuzione per raccogliere parametri OpenTelemetry a livello di istanza EC2 sui cluster Amazon ECS
Utilizza i passaggi di questa sezione per utilizzare AWS Distro per raccogliere parametri OpenTelemetry a livello di istanza EC2 su un cluster Amazon ECS. [Per ulteriori informazioni su Distro for, consulta Distro for. AWS OpenTelemetry AWS OpenTelemetry](https://aws.amazon.com/otel/)
In queste fasi si presuppone che tu disponga già di un cluster su Amazon ECS. Questo cluster deve essere implementato con il tipo di avvio EC2. Per ulteriori informazioni sull'utilizzo di AWS Distro for Open Telemetry con Amazon ECS e sulla configurazione di un cluster Amazon ECS per questo scopo, [consulta Configurazione di AWS Distro for OpenTelemetry Collector nei parametri a livello di istanza di Amazon Elastic Container Service for](https://aws-otel.github.io/docs/setup/ecs#3-setup-the-aws-otel-collector-for-ecs-ec2-instance-metrics) ECS EC2.
**Topics**
+ [Configurazione rapida utilizzando CloudFormation](#container-insights-ECS-OTEL-quicksetup)
+ [Configurazione manuale e personalizzata](#container-insights-ECS-OTEL-custom)
## Configurazione rapida utilizzando CloudFormation
Scarica il file CloudFormation modello per l'installazione di AWS Distro for OpenTelemetry collector for Amazon ECS su EC2. Esegui il seguente comando curl.
```
curl -O https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/deployment-template/ecs/aws-otel-ec2-instance-metrics-daemon-deployment-cfn.yaml
```
Dopo aver scaricato il file modello, aprilo e sostituiscilo *PATH\$1TO\$1CloudFormation\$1TEMPLATE* con il percorso in cui hai salvato il file modello. Quindi esportate i seguenti parametri ed eseguite il CloudFormation comando, come illustrato nel comando seguente.
+ **Cluster\$1Name**: il nome del cluster Amazon ECS
+ **AWS\$1RRegione**: la regione in cui verranno inviati i dati
+ **PATH\$1TO\$1 CloudFormation \$1TEMPLATE** — Il percorso in cui è stato salvato il file modello. CloudFormation
+ **comando**: per consentire a AWS Distro for OpenTelemetry collector di raccogliere i parametri a livello di istanza per Amazon ECS su Amazon EC2, devi specificare questo parametro. `--config=/etc/ecs/otel-instance-metrics-config.yaml`
```
ClusterName=Cluster_Name
Region=AWS_Region
command=--config=/etc/ecs/otel-instance-metrics-config.yaml
aws cloudformation create-stack --stack-name AOCECS-${ClusterName}-${Region} \
--template-body file://PATH_TO_CloudFormation_TEMPLATE \
--parameters ParameterKey=ClusterName,ParameterValue=${ClusterName} \
ParameterKey=CreateIAMRoles,ParameterValue=True \
ParameterKey=command,ParameterValue=${command} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${Region}
```
Dopo aver eseguito questo comando, utilizza la console Amazon ECS per verificare se l'attività è in esecuzione.
### Risoluzione dei problemi relativi alla configurazione rapida
Per verificare lo stato dello stack, inserisci il seguente comando. CloudFormation
```
ClusterName=cluster-name
Region=cluster-region
aws cloudformation describe-stack --stack-name AOCECS-$ClusterName-$Region --region $Region
```
Se il valore di `StackStatus` è diverso da `CREATE_COMPLETE` o `CREATE_IN_PROGRESS`, controlla gli eventi di stack per trovare l'errore. Inserire il seguente comando.
```
ClusterName=cluster-name
Region=cluster-region
aws cloudformation describe-stack-events --stack-name AOCECS-$ClusterName-$Region --region $Region
```
Per verificare lo stato del servizio daemon `AOCECS`, immetti il seguente comando. Nell'output, deve essere mostrato che `runningCount` è uguale a `desiredCount` nella sezione di implementazione. In caso contrario, controlla la sezione degli errori nell'output.
```
ClusterName=cluster-name
Region=cluster-region
aws ecs describe-services --services AOCECS-daemon-service --cluster $ClusterName --region $Region
```
Puoi anche utilizzare la console CloudWatch Logs per controllare il registro dell'agente. Cerca il gruppo**/aws/ecs/containerinsights/\$1ClusterName\$1/performance**log.
## Configurazione manuale e personalizzata
Segui i passaggi in questa sezione per distribuire manualmente la AWS Distro e raccogliere parametri OpenTelemetry a livello di istanza dai cluster Amazon ECS ospitati su istanze Amazon EC2.
### Fase 1: ruoli e policy necessari
Sono richiesti due ruoli IAM. Se non esistono già è necessario crearli. Per ulteriori informazioni su questi ruoli, consulta [Creazione della policy IAM](https://aws-otel.github.io/docs/setup/ecs/create-iam-policy) e [Creazione del ruolo IAM](https://aws-otel.github.io/docs/setup/ecs/create-iam-role).
### Fase 2: creazione di una definizione dell'attività
Crea una definizione di attività e usala per avviare Distro for as a daemon service. AWS OpenTelemetry
Per utilizzare il modello di definizione dell'attività per creare la definizione dell'attività, segui le istruzioni in [Creare una definizione di attività ECS EC2 per un'istanza EC2 con Collector](https://aws-otel.github.io/docs/setup/ecs/task-definition-for-ecs-ec2-instance). AWS OTel
Per utilizzare la console Amazon ECS per creare la definizione dell'attività, segui le istruzioni in [Install AWS OTel Collector creando la definizione delle attività tramite AWS console per i parametri delle istanze Amazon ECS EC2.](https://aws-otel.github.io/docs/setup/ecs/create-task-definition-instance-console)
### Fase 3: avvio del servizio daemon
Per avviare AWS Distro for OpenTelemetry as a daemon service, segui le istruzioni in Esegui la [tua attività su Amazon Elastic Container Service (Amazon ECS) usando il servizio daemon](https://aws-otel.github.io/docs/setup/ecs/run-daemon-service).
### (Facoltativo) Configurazione avanzata
Facoltativamente, puoi utilizzare SSM per specificare altre opzioni di configurazione per la AWS Distro per i OpenTelemetry tuoi cluster Amazon ECS ospitati su istanze Amazon EC2. [Per ulteriori informazioni sulla creazione di un file di configurazione, consulta Configurazione personalizzata. OpenTelemetry ](https://aws-otel.github.io/docs/setup/ecs#5-custom-opentelemetry-configuration) Per ulteriori informazioni sulle opzioni che è possibile utilizzare nel file di configurazione, consulta [AWS Container Insights Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/awscontainerinsightreceiver/README.md).
# Configurazione FireLens per l'invio di log a CloudWatch Logs
FireLens per Amazon ECS consente di utilizzare i parametri di definizione delle attività per indirizzare i log ad Amazon CloudWatch Logs per l'archiviazione e l'analisi dei log. FireLens [funziona con [Fluent Bit e Fluentd.](https://fluentbit.io/)](https://www.fluentd.org/) Forniamo un'immagine AWS per Fluent Bit, oppure puoi usare la tua immagine Fluent Bit o Fluentd. La creazione di definizioni di attività Amazon ECS con una FireLens configurazione è supportata utilizzando AWS SDKs AWS CLI, e Console di gestione AWS. Per ulteriori informazioni sui CloudWatch log, consulta [What is CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) Logs? .
Ci sono considerazioni chiave quando si utilizza FireLens per Amazon ECS. Per ulteriori informazioni, consulta [Considerazioni](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-considerations).
Per trovare le immagini AWS per Fluent Bit, consulta [Uso dell'immagine AWS for Fluent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-using-fluentbit.html) Bit.
Per creare una definizione di attività che utilizza una FireLens configurazione, vedere [Creazione di una definizione di attività che utilizza una FireLens ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html) configurazione.
**Esempio**
Il seguente esempio di definizione delle attività mostra come specificare una configurazione di log che inoltri i log a un gruppo di log CloudWatch Logs. Per ulteriori informazioni, consulta [What Is Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)? nella *Amazon CloudWatch Logs User Guide*.
Nelle opzioni di configurazione del log, specifica il nome del gruppo di log e la regione in cui esiste. Per fare in modo che Fluent Bit crei il gruppo di log per tuo conto, specifica `"auto_create_group":"true"`. Puoi anche specificare l'ID dell'attività come prefisso del flusso di log utile durante l'operazione di filtro. Per ulteriori informazioni, consulta [Fluent Bit Plugin for CloudWatch Logs](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit/blob/mainline/README.md).
```
{
"family": "firelens-example-cloudwatch",
"taskRoleArn": "arn:aws:iam::123456789012:role/ecs_task_iam_role",
"containerDefinitions": [
{
"essential": true,
"image": "906394416424.dkr.ecr.us-west-2.amazonaws.com/aws-for-fluent-bit:latest",
"name": "log_router",
"firelensConfiguration": {
"type": "fluentbit"
},
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "firelens-container",
"awslogs-region": "us-west-2",
"awslogs-create-group": "true",
"awslogs-stream-prefix": "firelens"
}
},
"memoryReservation": 50
},
{
"essential": true,
"image": "nginx",
"name": "app",
"logConfiguration": {
"logDriver":"awsfirelens",
"options": {
"Name": "cloudwatch_logs",
"region": "us-west-2",
"log_key": "log",
"log_group_name": "/aws/ecs/containerinsights/my-cluster/application",
"auto_create_group": "true",
"log_stream_name": "my-task-id"
}
},
"memoryReservation": 100
}
]
}
```
# Configurazione di Container Insights su Amazon EKS e Kubernetes
Approfondimenti sui container è supportato nelle versioni 1.23 e successive di Amazon EKS. Il metodo di installazione rapida è supportato solo nelle versioni 1.24 e successive.
Il processo generale per la configurazione di Container Insights su Amazon EKS o Kubernetes è il seguente:
1. Verificare di disporre dei prerequisiti necessari.
1. Configura il componente aggiuntivo Amazon CloudWatch Observability EKS, l' CloudWatch agente o la AWS distribuzione OpenTelemetry sul tuo cluster a cui inviare i parametri. CloudWatch
**Nota**
Per utilizzare Container Insights con osservabilità migliorata per Amazon EKS, devi utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS o l'agente. CloudWatch Per ulteriori informazioni su questa versione di Approfondimenti sui container, consulta la pagina [Container Insights con osservabilità migliorata per Amazon EKS](container-insights-detailed-metrics.md).
Per utilizzare Container Insights con Fargate, è necessario utilizzare AWS Distro for. OpenTelemetry Approfondimenti sui container con osservabilità migliorata per Amazon EKS non è supportato su Fargate.
**Nota**
Container Insights ora supporta i nodi worker Windows in un cluster Amazon EKS. Container Insights con osservabilità migliorata per Amazon EKS è anche supportato su Windows. Per informazioni su come abilitare Container Insights su Windows, consulta [CloudWatch Utilizzo dell'agente con l'osservabilità avanzata di Container Insights abilitata](Container-Insights-EKS-agent.md).
Per utilizzare Container Insights con le OpenTelemetry metriche, installa la versione del componente aggiuntivo Amazon CloudWatch Observability EKS o una versione `v6.0.1-eksbuild.1` successiva. Per ulteriori informazioni, consulta [Container Insights con OpenTelemetry metriche per Amazon EKS](container-insights-otel-metrics.md).
Configura Fluent Bit o Fluentd per inviare i log a Logs. CloudWatch (Questa opzione è abilitata per impostazione predefinita se installi il componente aggiuntivo Amazon CloudWatch Observability EKS.)
Puoi eseguire questi passaggi contemporaneamente come parte della configurazione di avvio rapido se utilizzi l' CloudWatch agente o eseguirli separatamente.
1. (Facoltativo) Impostare la registrazione del piano di controllo Amazon EKS.
1. (Facoltativo) Configura l' CloudWatch agente come endpoint StatSD sul cluster a cui inviare le metriche StatsD. CloudWatch
1. (Facoltativo) Abilita i log di accesso di App Mesh Envoy.
Con la versione originale di Approfondimenti sui container, i parametri raccolti e i log importati vengono addebitati come parametri personalizzati. Con Approfondimenti sui container con osservabilità migliorata per Amazon EKS, i parametri e i log di Approfondimenti sui container vengono addebitati per osservazione anziché per parametro archiviato o log importato. Per ulteriori informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Topics**
+ [Verifica dei prerequisiti per Container Insights in CloudWatch](Container-Insights-prerequisites.md)
+ [CloudWatch Utilizzo dell'agente con l'osservabilità avanzata di Container Insights abilitata](Container-Insights-EKS-agent.md)
+ [Utilizzo di AWS Distro per OpenTelemetry](Container-Insights-EKS-otel.md)
+ [Invia log a Logs CloudWatch](Container-Insights-EKS-logs.md)
+ [Aggiornamento o eliminazione di Container Insights su Amazon EKS e Kubernetes](ContainerInsights-update-delete.md)
# Verifica dei prerequisiti per Container Insights in CloudWatch
Prima di installare Container Insights su Amazon EKS o Kubernetes, verifica quanto segue. Questi prerequisiti si applicano indipendentemente dal fatto che tu stia utilizzando l' CloudWatch agente o AWS Distro OpenTelemetry per configurare Container Insights sui cluster Amazon EKS.
+ Disponi di un cluster Amazon EKS o Kubernetes funzionale con nodi collegati in una delle regioni che supporta Container Insights per Amazon EKS e Kubernetes. Per l'elenco delle regioni supportate, consulta [Container Insights](ContainerInsights.md).
+ Disponi di `kubectl` installato e in esecuzione. Per ulteriori informazioni, consulta la pagina relativa all'[installazione di `kubectl`](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) nella *Guida per l'utente di Amazon EKS*.
+ Se utilizzi Kubernetes in esecuzione AWS anziché Amazon EKS, sono necessari anche i seguenti prerequisiti:
+ Assicurati che il cluster Kubernetes abbia abilitato il controllo degli accessi basato su ruoli (RBAC). Per ulteriori informazioni, consulta [Utilizzo dell'autorizzazione RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) nella documentazione di riferimento di Kubernetes.
+ Il kubelet ha abilitato la modalità di autorizzazione Webhook. Per ulteriori informazioni, consulta [Autenticazione/autorizzazione Kubelet](https://kubernetes.io/docs/reference/access-authn-authz/kubelet-authn-authz/) nella documentazione di riferimento di Kubernetes.
È inoltre necessario concedere le autorizzazioni IAM per consentire ai nodi di lavoro Amazon EKS di inviare parametri e log. CloudWatch Ci sono due modi per effettuare questa operazione:
+ Collega una policy al ruolo IAM dei nodi di lavoro. Questo metodo funziona sia per i cluster Amazon EKS che per altri cluster Kubernetes.
+ Utilizza un ruolo IAM per gli account di servizio per il cluster e collega la policy a questo ruolo. Questo metodo funziona solo per i cluster Amazon EKS.
La prima opzione concede le autorizzazioni CloudWatch per l'intero nodo, mentre l'utilizzo di un ruolo IAM per l'account di servizio consente di CloudWatch accedere solo ai pod daemonset appropriati.
**Collegamento di una policy al ruolo IAM dei nodi di lavoro**
Attieniti alla seguente procedura per collegare la policy al ruolo IAM dei nodi di lavoro. Questa procedura funziona sia per i cluster Amazon EKS che per i cluster Kubernetes esterni ad Amazon EKS.
**Per collegare la policy necessaria al ruolo IAM per i nodi worker**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona una delle istanze dei nodi worker e scegli il ruolo IAM nella descrizione.
1. Nella pagina del ruolo IAM, scegli **Attach policies** (Collega policy).
1. Nell'elenco delle politiche, seleziona la casella di controllo accanto a. **CloudWatchAgentServerPolicy** Se necessario, utilizzare la casella di ricerca per trovare questa policy.
1. Scegli **Collega policy**.
Se stai eseguendo un cluster Kubernetes all'esterno di Amazon EKS, è possibile che tu non disponga già di un ruolo IAM associato ai nodi worker. In questo caso, occorre innanzitutto collegare un ruolo IAM all'istanza e quindi aggiungere la policy come illustrato nelle fasi precedenti. Per ulteriori informazioni sul collegamento di un ruolo a un'istanza, consulta [Collegamento di un ruolo IAM a un'istanza](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/iam-roles-for-amazon-ec2.html#attach-iam-role) nella *Guida per l'utente di Amazon EC2*.
Se esegui un cluster Kubernetes all'esterno di Amazon EKS e desideri raccogliere il volume EBS IDs nelle metriche, devi aggiungere un'altra policy al ruolo IAM associato all'istanza. Aggiungi quanto segue come una policy inline. Per ulteriori informazioni, consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *Guida per l'utente di IAM*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:DescribeVolumes"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
**Utilizzo di un ruolo dell'account del servizio IAM**
Questo metodo funziona solo nei cluster Amazon EKS.
**Per concedere l'autorizzazione all' CloudWatch utilizzo del ruolo di un account di servizio IAM**
1. Se non l'hai già fatto, abilita i ruoli IAM per gli account del servizio nel cluster. Per ulteriori informazioni, consulta [Abilitazione dei ruoli IAM per gli account di servizio nel cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
1. Se non l'hai già fatto, configura l'account del servizio per utilizzare il ruolo IAM. Per ulteriori informazioni, consulta la pagina [Configurazione di un account di servizio Kubernetes per assumere un ruolo IAM](https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html).
Quando crei il ruolo, collega la policy **CloudWatchAgentServerPolicy**IAM al ruolo oltre alla policy che crei per il ruolo. Inoltre, l'account di servizio Kubernetes associato collegato a questo ruolo deve essere creato nello spazio dei `amazon-cloudwatch` nomi, dove i daemonset CloudWatch e Fluent Bit verranno distribuiti nei passaggi successivi
1. In caso contrario, collega il ruolo IAM a un account del servizio nel cluster. Per ulteriori informazioni, consulta la pagina [Configurazione di un account di servizio Kubernetes per assumere un ruolo IAM](https://docs.aws.amazon.com/eks/latest/userguide/associate-service-account-role.html).
# CloudWatch Utilizzo dell'agente con l'osservabilità avanzata di Container Insights abilitata
Utilizza le istruzioni in una delle seguenti sezioni per configurare Container Insights su un cluster Amazon EKS o un cluster Kubernetes utilizzando l'agente. CloudWatch Le istruzioni per l'installazione rapida sono supportate solo nelle versioni 1.24 e successive di Amazon EKS.
**Nota**
Puoi installare Approfondimenti sui container seguendo le istruzioni riportate in una delle sezioni successive. Non è necessario seguire tutti e tre i set di istruzioni.
**Topics**
+ [Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS](Container-Insights-setup-EKS-addon.md)
+ [Configurazione di Quick Start per Container Insights su Amazon EKS e Kubernetes](Container-Insights-setup-EKS-quickstart.md)
+ [Configurazione dell' CloudWatch agente per raccogliere le metriche del cluster](Container-Insights-setup-metrics.md)
# Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS
Puoi utilizzare il componente aggiuntivo Amazon EKS per installare Approfondimenti sui container con osservabilità migliorata per Amazon EKS. Il componente aggiuntivo installa l' CloudWatch agente per inviare i parametri dell'infrastruttura dal cluster, installa Fluent Bit per inviare i log dei container e consente inoltre di inviare la telemetria delle prestazioni dell'applicazione. CloudWatch [Segnali applicativi](CloudWatch-Application-Monitoring-Sections.md)
Quando utilizzi il componente aggiuntivo Amazon EKS versione 1.5.0 o successive, Container Insights è abilitato su entrambi i nodi worker Linux e Windows del cluster. Application Signals non è supportato su Windows in Amazon EKS.
Il componente aggiuntivo Amazon EKS non è supportato per i cluster che eseguono Kubernetes anziché Amazon EKS.
Per ulteriori informazioni sul componente aggiuntivo Amazon CloudWatch Observability EKS, consulta. [Installa l' CloudWatch agente con il componente aggiuntivo Amazon CloudWatch Observability EKS o il grafico Helm](install-CloudWatch-Observability-EKS-addon.md)
Se si utilizza la versione 3.1.0 o successiva del componente aggiuntivo, è possibile utilizzare EKS Pod Identity per concedere le autorizzazioni richieste al componente aggiuntivo. EKS Pod Identity è l'opzione consigliata e offre vantaggi come il privilegio minimo, la rotazione delle credenziali e la verificabilità. Inoltre, l'utilizzo di EKS Pod Identity consente di installare il componente aggiuntivo EKS come parte della creazione del cluster stesso.
**Per installare il componente aggiuntivo Amazon CloudWatch Observability EKS**
1. Segui i passaggi di [Associazione EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create/) per creare il ruolo IAM e configurare l'agente EKS Pod Identity.
1. Allega una policy IAM che concede le autorizzazioni richieste al tuo ruolo. Sostituiscilo *my-role* con il nome del tuo ruolo IAM del passaggio precedente.
```
aws iam attach-role-policy \
--role-name my-role \
--policy-arn=arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy
```
1. Immetti il comando seguente, utilizzando il ruolo IAM creato nel passaggio precedente:
```
aws eks create-addon \
--addon-name amazon-cloudwatch-observability \
--cluster-name my-cluster-name \
--pod-identity-associations serviceAccount=cloudwatch-agent,roleArn=arn:aws:iam::111122223333:role/my-role
```
# Configurazione di Quick Start per Container Insights su Amazon EKS e Kubernetes
**Importante**
Se stai installando Container Insights su un cluster Amazon EKS, ti consigliamo di utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS per l'installazione, anziché seguire le istruzioni in questa sezione. Inoltre, per recuperare reti di elaborazione accelerate, devi utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS. Per ulteriori informazioni e istruzioni, consulta [Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS](Container-Insights-setup-EKS-addon.md).
Per completare la configurazione di Container Insights, puoi seguire le istruzioni di avvio rapido in questa sezione. Se esegui l'installazione su un cluster Amazon EKS e segui le istruzioni riportate in questa sezione a partire dal 6 novembre 2023, sul cluster installerai Approfondimenti sui container con osservabilità migliorata per Amazon EKS.
**Importante**
Prima di completare la procedura descritta in questa sezione, è necessario verificare i prerequisiti, incluse le autorizzazioni IAM. Per ulteriori informazioni, consulta la pagina [Verifica dei prerequisiti per Container Insights in CloudWatch](Container-Insights-prerequisites.md).
In alternativa, puoi seguire le istruzioni nelle due sezioni seguenti, [Configurazione dell' CloudWatch agente per raccogliere le metriche del cluster](Container-Insights-setup-metrics.md) e [Invia log a Logs CloudWatch](Container-Insights-EKS-logs.md). Queste sezioni forniscono ulteriori dettagli di configurazione su come l' CloudWatch agente funziona con Amazon EKS e Kubernetes, ma richiedono l'esecuzione di ulteriori passaggi di installazione.
Con la versione originale di Approfondimenti sui container, i parametri raccolti e i log importati vengono addebitati come parametri personalizzati. Con Approfondimenti sui container con osservabilità migliorata per Amazon EKS, i parametri e i log di Approfondimenti sui container vengono addebitati per osservazione anziché per parametro archiviato o log importato. Per ulteriori informazioni sui CloudWatch prezzi, consulta la pagina [ CloudWatchdei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Nota**
Amazon ha ora lanciato Fluent Bit come soluzione di log predefinita per Container Insights con significativi miglioramenti delle prestazioni. Ti consigliamo di utilizzare Fluent Bit anziché Fluentd.
## Avvio rapido con l'operatore CloudWatch agente e Fluent Bit
Esistono due configurazioni per Fluent Bit: una versione ottimizzata e una versione che offre un'esperienza più simile a Fluentd. La configurazione Quick Start utilizza la versione ottimizzata. Per maggiori dettagli sulla configurazione compatibile con Fluentd, consulta [Configura Fluent Bit come per inviare log a Logs DaemonSet CloudWatch](Container-Insights-setup-logs-FluentBit.md).
L'operatore CloudWatch agente è un contenitore aggiuntivo che viene installato in un cluster Amazon EKS. È modellato sull' OpenTelemetry Operator for Kubernetes. L'operatore gestisce il ciclo di vita delle risorse Kubernetes in un cluster. Installa CloudWatch Agent, DCGM Exporter (NVIDIA) e AWS Neuron Monitor su un cluster Amazon EKS e li gestisce. Fluent Bit e CloudWatch Agent for Windows vengono installati direttamente in un cluster Amazon EKS senza che l'operatore li gestisca.
Per una soluzione di autorità di certificazione più sicura e ricca di funzionalità, l'operatore dell' CloudWatch agente richiede cert-manager, una soluzione ampiamente adottata per la gestione dei certificati TLS in Kubernetes. L'utilizzo di cert-manager semplifica il processo di ottenimento, rinnovo, gestione e utilizzo di questi certificati. Garantisce che i certificati siano validi e aggiornati e tenta di rinnovarli in un momento configurato prima della scadenza. cert-manager facilita anche l'emissione di certificati da una varietà di fonti supportate, tra cui Certificate Manager AWS Private Certificate Authority.
**Per implementare Container Insights utilizzando l'avvio rapido**
1. Installa cert-manager se non è già installato nel cluster. Per ulteriori informazioni, consulta [Installazione di cert-manager](https://cert-manager.io/docs/installation/).
1. Installa le definizioni di risorse personalizzate (CRD) immettendo i seguenti comandi:
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-custom-resource-definitions.yaml | kubectl apply --server-side -f -
```
1. Installa l'operatore immettendo il seguente comando. Sostituisci *my-cluster-name* con il nome del tuo cluster Amazon EKS o Kubernetes e sostituiscilo *my-cluster-region* con il nome della regione in cui vengono pubblicati i log. Ti consigliamo di utilizzare la stessa regione in cui è distribuito il cluster per ridurre i costi di trasferimento dei AWS dati in uscita.
```
ClusterName=my-cluster-name
RegionName=my-cluster-region
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-operator-rendered.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/g;s/{{region_name}}/'${RegionName}'/g' | kubectl apply -f -
```
Ad esempio, per implementare Container Insights sul cluster denominato `MyCluster` e pubblicare i log e i parametri negli Stati Uniti occidentali (Oregon), immetti il comando seguente.
```
ClusterName='MyCluster'
RegionName='us-west-2'
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-operator-rendered.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/g;s/{{region_name}}/'${RegionName}'/g' | kubectl apply -f -
```
**Migrazione da Container Insights**
Se disponi già di Container Insights configurato in un cluster Amazon EKS e desideri migrare a Container Insights con osservabilità migliorata per Amazon EKS, consulta [Aggiornamento a Container Insights con osservabilità migliorata per Amazon EKS in CloudWatch](Container-Insights-upgrade-enhanced.md)
**Eliminazione di Container Insights**
Se si desidera rimuovere Container Insights dopo aver utilizzato la configurazione di avvio rapido, immetti i comandi seguenti.
```
ClusterName=my-cluster-name
RegionName=my-cluster-region
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-operator-rendered.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/g;s/{{region_name}}/'${RegionName}'/g' | kubectl delete -f -
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-custom-resource-definitions.yaml | kubectl delete -f -
```
# Configurazione dell' CloudWatch agente per raccogliere le metriche del cluster
**Importante**
Se stai installando Container Insights su un cluster Amazon EKS, ti consigliamo di utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS per l'installazione, anziché seguire le istruzioni in questa sezione. Per ulteriori informazioni e istruzioni, consulta [Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS](Container-Insights-setup-EKS-addon.md).
Per configurare Container Insights per raccogliere i parametri, puoi seguire le fasi in [Configurazione di Quick Start per Container Insights su Amazon EKS e Kubernetes](Container-Insights-setup-EKS-quickstart.md) oppure le fasi in questa sezione. Nei passaggi seguenti, configuri l' CloudWatch agente in modo che sia in grado di raccogliere metriche dai tuoi cluster.
Se esegui l'installazione su un cluster Amazon EKS e segui le istruzioni riportate in questa sezione a partire dal 6 novembre 2023, sul cluster installerai Approfondimenti sui container con osservabilità migliorata per Amazon EKS.
## Passaggio 1: creare un namespace per CloudWatch
Usa il passaggio seguente per creare uno spazio dei nomi Kubernetes richiesto. `amazon-cloudwatch` CloudWatch Puoi ignorare questa fase se questo spazio dei nomi è già stato creato.
**Per creare uno spazio dei nomi per CloudWatch**
+ Inserire il seguente comando.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cloudwatch-namespace.yaml
```
## Fase 2: creazione di un account di servizio nel cluster
Utilizza uno dei seguenti metodi per creare un account di servizio per l' CloudWatch agente, se non ne hai già uno.
+ Utilizzare `kubectl`
+ Utilizzare un file `kubeconfig`
### Utilizzare `kubectl` per l'autenticazione
**Da utilizzare `kubectl` per creare un account di servizio per l' CloudWatch agente**
+ Inserire il seguente comando.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-serviceaccount.yaml
```
Se non hai seguito i passaggi precedenti, ma disponi già di un account di servizio per l' CloudWatch agente che desideri utilizzare, devi assicurarti che abbia le seguenti regole. Inoltre, nelle restanti fasi dell'installazione di Container Insights devi utilizzare il nome di quell'account di servizio invece di `cloudwatch-agent`.
```
rules:
- apiGroups: [""]
resources: ["pods", "nodes", "endpoints"]
verbs: ["list", "watch"]
- apiGroups: [ "" ]
resources: [ "services" ]
verbs: [ "list", "watch" ]
- apiGroups: ["apps"]
resources: ["replicasets", "daemonsets", "deployments", "statefulsets"]
verbs: ["list", "watch"]
- apiGroups: ["batch"]
resources: ["jobs"]
verbs: ["list", "watch"]
- apiGroups: [""]
resources: ["nodes/proxy"]
verbs: ["get"]
- apiGroups: [""]
resources: ["nodes/stats", "configmaps", "events"]
verbs: ["create", "get"]
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["cwagent-clusterleader"]
verbs: ["get","update"]
- nonResourceURLs: ["/metrics"]
verbs: ["get", "list", "watch"]
- apiGroups: [ "discovery.k8s.io" ]
resources: [ "endpointslices" ]
verbs: [ "list", "watch", "get" ]
```
### Utilizzare `kubeconfig` per l'autenticazione
In alternativa, puoi utilizzare un file `kubeconfig` per l'autenticazione. Questo metodo consente di aggirare la necessità di un account di servizio specificando direttamente il `kubeconfig` percorso nella configurazione dell' CloudWatch agente. Inoltre, consente di eliminare la dipendenza dall'API del piano di controllo di Kubernetes per l'autenticazione, semplificando la configurazione e potenzialmente aumentando la sicurezza grazie alla gestione dell'autenticazione tramite il file kubeconfig.
Per utilizzare questo metodo, aggiorna il file di configurazione dell' CloudWatch agente per specificare il percorso `kubeconfig` del file, come nell'esempio seguente.
```
{
"logs": {
"metrics_collected": {
"kubernetes": {
"cluster_name": "YOUR_CLUSTER_NAME",
"enhanced_container_insights": false,
"accelerated_compute_metrics": false,
"tag_service": false,
"kube_config_path": "/path/to/your/kubeconfig"
"host_ip": "HOSTIP"
}
}
}
}
```
Per creare un file `kubeconfig`, crea una richiesta di firma del certificato (CSR) per l'utente `admin/{create_your_own_user}` con il ruolo `system:masters` in Kubernetes. Quindi firma con l'Autorità di certificazione (CA) del cluster Kubernetes e crea il file `kubeconfig`.
## Fase 3: Creare un ConfigMap file per l' CloudWatch agente
Utilizza i seguenti passaggi per creare un messaggio ConfigMap per l' CloudWatch agente.
**Per creare un file ConfigMap per l' CloudWatch agente**
1. Scaricate il file ConfigMap YAML sul vostro host `kubectl` client eseguendo il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-configmap-enhanced.yaml
```
1. Modifica il file YAML scaricato come segue:
+ **cluster\$1name**: nella sezione `kubernetes`, sostituisci `{{cluster_name}}` con il nome del cluster. Rimuovi i caratteri `{{}}`. In alternativa, se stai utilizzando un cluster Amazon EKS, puoi eliminare il campo `"cluster_name"` e il valore. In tal caso, l' CloudWatch agente rileva il nome del cluster dai tag Amazon EC2.
1. (Facoltativo) Apporta ulteriori modifiche in ConfigMap base ai tuoi requisiti di monitoraggio, come segue:
+ **metrics\$1collection\$1interval**: nella sezione `kubernetes`, puoi specificare ogni quanto l'agente raccoglie i parametri. Il valore predefinito è 60 secondi. L'intervallo di raccolta cadvisor predefinito in Kubelet è 15 secondi, quindi non impostare questo valore su meno di 15 secondi.
+ **endpoint\$1override** — Nella `logs` sezione, puoi specificare l'endpoint CloudWatch Logs se desideri sovrascrivere l'endpoint predefinito. Questo può essere necessario se stai pubblicando da un cluster in un VPC e desideri che i dati vadano a un endpoint VPC.
+ **force\$1flush\$1interval — Nella `logs` sezione, puoi specificare l'intervallo** per il raggruppamento in batch degli eventi di registro prima che vengano pubblicati su Logs. CloudWatch Il valore predefinito è 5 secondi.
+ **region**: per impostazione predefinita, l'agente pubblica i parametri nella regione in cui si trova il nodo worker. Per sostituire questa impostazione, è possibile aggiungere un campo `region` nella sezione `agent`, ad esempio `"region":"us-west-2"`.
+ sezione **statsd** — Se desideri che l'agente CloudWatch Logs venga eseguito anche come listener StatsD in ogni nodo di lavoro del cluster, puoi aggiungere una `statsd` sezione alla `metrics` sezione, come nell'esempio seguente. Per informazioni sulle altre opzioni StatsD per questa sezione, consulta [Recupero dei parametri personalizzati con StatsD](CloudWatch-Agent-custom-metrics-statsd.md).
```
"metrics": {
"metrics_collected": {
"statsd": {
"service_address":":8125"
}
}
}
```
Di seguito un esempio completo della sezione JSON. Se utilizzi un file `kubeconfig` per l'autenticazione, aggiungi il parametro `kube_config_path` per specificare il percorso del tuo file kubeconfig.
```
{
"agent": {
"region": "us-east-1"
},
"logs": {
"metrics_collected": {
"kubernetes": {
"cluster_name": "MyCluster",
"metrics_collection_interval": 60,
"kube_config_path": "/path/to/your/kubeconfig" //if using kubeconfig for authentication
}
},
"force_flush_interval": 5,
"endpoint_override": "logs.us-east-1.amazonaws.com"
},
"metrics": {
"metrics_collected": {
"statsd": {
"service_address": ":8125"
}
}
}
}
```
1. Crea il file ConfigMap nel cluster eseguendo il comando seguente.
```
kubectl apply -f cwagent-configmap-enhanced.yaml
```
## Fase 4: Implementare l' CloudWatch agente come DaemonSet
Per completare l'installazione dell' CloudWatch agente e iniziare a raccogliere le metriche dei container, procedi nel seguente modo.
**Per distribuire l' CloudWatch agente come DaemonSet**
1.
+ Se non desideri utilizzare StatsD sul cluster, immetti il comando seguente.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-daemonset.yaml
```
+ Se desideri utilizzare StatsD, procedi nel modo seguente:
1. Scarica il file DaemonSet YAML sull'host `kubectl` client eseguendo il comando seguente.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-daemonset.yaml
```
1. Rimuovi il commento della sezione `port` nel file `cwagent-daemonset.yaml` come descritto di seguito:
```
ports:
- containerPort: 8125
hostPort: 8125
protocol: UDP
```
1. Distribuisci l' CloudWatch agente nel tuo cluster eseguendo il comando seguente.
```
kubectl apply -f cwagent-daemonset.yaml
```
1. Distribuisci l' CloudWatch agente sui nodi Windows del cluster eseguendo il comando seguente. Il listener StatSD non è supportato dall' CloudWatch agente in Windows.
```
kubectl apply -f cwagent-daemonset-windows.yaml
```
1. Convalida che l'agente venga implementato eseguendo il seguente comando.
```
kubectl get pods -n amazon-cloudwatch
```
Al termine, l' CloudWatch agente crea un gruppo di log denominato `/aws/containerinsights/Cluster_Name/performance` e invia gli eventi del registro delle prestazioni a questo gruppo di log. Se lo configuri anche come listener StatsD, l'agente ascolta anche i parametri StatsD sulla porta 8125 con l'indirizzo IP del nodo dove è pianificato il pod dell'applicazione.
### Risoluzione dei problemi
Se l'agente non viene implementato correttamente, prova quanto segue:
+ Per ottenere l'elenco di pod esegui il seguente comando.
```
kubectl get pods -n amazon-cloudwatch
```
+ Esegui il comando seguente e controlla gli eventi nella parte inferiore dell'output.
```
kubectl describe pod pod-name -n amazon-cloudwatch
```
+ Esegui il comando seguente per controllare i log.
```
kubectl logs pod-name -n amazon-cloudwatch
```
# Utilizzo di AWS Distro per OpenTelemetry
Puoi configurare Container Insights per raccogliere metriche dai cluster Amazon EKS utilizzando AWS Distro for collector. OpenTelemetry [Per ulteriori informazioni su Distro for, AWS consulta Distro for OpenTelemetry.AWS OpenTelemetry](https://aws.amazon.com/otel/)
**Importante**
Se si installa utilizzando AWS Distro for OpenTelemetry, si installa Container Insights ma non si ottiene Container Insights con osservabilità migliorata per Amazon EKS. Non raccoglierai i parametri dettagliati supportati in Approfondimenti sui container con osservabilità migliorata per Amazon EKS.
La modalità di configurazione di Container Insights varia a seconda che il cluster sia ospitato su istanze Amazon EC2 o su AWS Fargate.
## Cluster Amazon EKS ospitati su Amazon EC2
Se non lo hai già fatto, assicurati di aver soddisfatto i prerequisiti inclusi i ruoli IAM necessari. Per ulteriori informazioni, consulta la pagina [Verifica dei prerequisiti per Container Insights in CloudWatch](Container-Insights-prerequisites.md).
Amazon fornisce un grafico Helm che puoi utilizzare per configurare il monitoraggio di Amazon Elastic Kubernetes Service su Amazon EC2. Questo monitoraggio utilizza AWS Distro for OpenTelemetry (ADOT) Collector per le metriche e Fluent Bit per i log. Pertanto, il grafico Helm è utile per i clienti che utilizzano Amazon EKS su Amazon EC2 e desiderano raccogliere metriche e log da inviare a Container Insights. CloudWatch Per ulteriori informazioni su questo grafico di Helm, consulta il grafico [ADOT Helm per EKS sulle metriche e i log di EC2 su](https://github.com/aws-observability/aws-otel-helm-charts/tree/main/charts/adot-exporter-for-eks-on-ec2) Amazon Container Insights. CloudWatch
In alternativa, puoi usare le istruzioni nel resto di questa sezione.
Innanzitutto, distribuisci AWS Distro for OpenTelemetry collector come file utilizzando il seguente comando. DaemonSet
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/deployment-template/eks/otel-container-insights-infra.yaml |
kubectl apply -f -
```
Utilizza il comando seguente per confermare che il raccoglitore è in esecuzione.
```
kubectl get pods -l name=aws-otel-eks-ci -n aws-otel-eks
```
Se l'output di questo comando include più pod nello stato `Running`, il raccoglitore è in esecuzione e raccoglie parametri dal cluster. Il raccoglitore crea un gruppo di log denominato `aws/containerinsights/cluster-name/performance` e invia gli eventi di log delle prestazioni allo stesso.
Per informazioni su come visualizzare le metriche di Container Insights in, consulta. CloudWatch [Visualizzazione dei parametri di Container Insights](Container-Insights-view-metrics.md)
AWS ha anche fornito la documentazione GitHub relativa a questo scenario. [Se desideri personalizzare le metriche e i log pubblicati da Container Insights, consulta https://aws-otel.github. io/docs/getting-started/container-insights/eks-infra.](https://aws-otel.github.io/docs/getting-started/container-insights/eks-infra)
## Cluster Amazon EKS ospitati su Fargate
Per istruzioni su come configurare e distribuire un ADOT Collector per raccogliere i parametri di sistema dai carichi di lavoro distribuiti in un cluster Amazon EKS su Fargate e inviarli a Container CloudWatch Insights, consulta Container [Insights EKS](https://aws-otel.github.io/docs/getting-started/container-insights/eks-fargate) Fargate nella distribuzione per la documentazione. AWS OpenTelemetry
# Invia log a Logs CloudWatch
Per inviare i log dai tuoi contenitori ad Amazon CloudWatch Logs, puoi utilizzare Fluent Bit. Per ulteriori informazioni, consulta il sito di [Fluent Bit](https://fluentbit.io/).
**Nota**
A partire dal 10 febbraio 2025, AWS il supporto per FluentD come server di inoltro di log per Logs è obsoleto. CloudWatch Ti consigliamo di utilizzare Fluent Bit, un'alternativa leggera ed efficiente in termini di risorse. Le implementazioni Fluentd esistenti continueranno a funzionare. Migra la tua pipeline di registrazione a Fluent Bit per garantire un supporto continuo e prestazioni ottimali.
Precedentemente, Container Insights supportava anche l'utilizzo di Fluentd per inviare i log dai container. Fluentd è stato reso obsoleto e ora non è supportato per Container Insights. Pertanto, è consigliato l'utilizzo di Fluent Bit.
**Topics**
+ [Configura Fluent Bit come per inviare log a Logs DaemonSet CloudWatch](Container-Insights-setup-logs-FluentBit.md)
+ [(Facoltativo) Impostare la registrazione del piano di controllo Amazon EKS](Container-Insights-setup-control-plane-logging.md)
+ [(Facoltativo) Abilitazione di funzione Use\$1Kubelet per cluster di grandi dimensioni](ContainerInsights-use-kubelet.md)
# Configura Fluent Bit come per inviare log a Logs DaemonSet CloudWatch
Le seguenti sezioni aiutano a implementare Fluent Bit per inviare i log dai contenitori ai Logs. CloudWatch
**Topics**
+ [Configurazione di Fluent Bit](#Container-Insights-FluentBit-setup)
+ [Supporto per log multi-linea](#ContainerInsights-fluentbit-multiline)
+ [Riduzione del volume di log da Fluent Bit (facoltativo)](#ContainerInsights-fluentbit-volume)
+ [Risoluzione dei problemi](#Container-Insights-FluentBit-troubleshoot)
+ [Pannello di controllo](#Container-Insights-FluentBit-dashboard)
## Configurazione di Fluent Bit
Per configurare Fluent Bit per raccogliere log dai container, puoi seguire le fasi in [Configurazione di Quick Start per Container Insights su Amazon EKS e Kubernetes](Container-Insights-setup-EKS-quickstart.md) o seguire le fasi in questa sezione.
Con entrambi i metodi, il ruolo IAM collegato ai nodi del cluster deve disporre di autorizzazioni sufficienti. Per ulteriori informazioni sulle autorizzazioni necessarie per l'esecuzione di un cluster Amazon EKS, consulta [Policy, ruoli e autorizzazioni IAM di Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/IAM_policies.html) nella *Guida per l'utente Amazon EKS*.
Nei passaggi seguenti, configuri Fluent Bit come DaemOnset per inviare i log ai Logs. CloudWatch Una volta completata questa fase, Fluent Bit crea i seguenti gruppi di log se non esistono già.
**Importante**
Se hai già configurato FluentD in Container Insights e FluentD non funziona come previsto (questo può succedere se usi `containerd` il runtime), devi disinstallarlo prima di installare DaemonSet Fluent Bit per evitare che FluentBit elabori i messaggi di registro degli errori FluentD. Altrimenti, è necessario disinstallare FluentD immediatamente dopo aver installato con successo Fluent Bit. La disinstallazione di Fluentd dopo l'installazione di Fluent Bit garantisce la continuità della registrazione durante questo processo di migrazione. È necessario solo uno tra Fluent Bit o FluentD per inviare i log ai Logs. CloudWatch
| Nome del gruppo di log | Origine del log |
| --- | --- |
| `/aws/containerinsights/Cluster_Name/application` | Tutti i file di log in `/var/log/containers` |
| `/aws/containerinsights/Cluster_Name/host` | I log da `/var/log/dmesg`, `/var/log/secure` e `/var/log/messages` |
| `/aws/containerinsights/Cluster_Name/dataplane` | I log in `/var/log/journal` per `kubelet.service` `kubeproxy.service` e `docker.service`. |
**Per installare Fluent Bit per inviare i log dai contenitori ai Logs CloudWatch**
1. Se non hai già uno spazio dei nomi chiamato `amazon-cloudwatch`, creane uno inserendo il seguente comando:
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cloudwatch-namespace.yaml
```
1. Esegui il comando seguente per creare un ConfigMap nome `cluster-info` con il nome del cluster e la regione a cui inviare i log. Sostituisci *cluster-name* e *cluster-region* con il nome e la regione del cluster.
```
ClusterName=cluster-name
RegionName=cluster-region
FluentBitHttpPort='2020'
FluentBitReadFromHead='Off'
[[ ${FluentBitReadFromHead} = 'On' ]] && FluentBitReadFromTail='Off'|| FluentBitReadFromTail='On'
[[ -z ${FluentBitHttpPort} ]] && FluentBitHttpServer='Off' || FluentBitHttpServer='On'
kubectl create configmap fluent-bit-cluster-info \
--from-literal=cluster.name=${ClusterName} \
--from-literal=http.server=${FluentBitHttpServer} \
--from-literal=http.port=${FluentBitHttpPort} \
--from-literal=read.head=${FluentBitReadFromHead} \
--from-literal=read.tail=${FluentBitReadFromTail} \
--from-literal=logs.region=${RegionName} -n amazon-cloudwatch
```
In questo comando, il `FluentBitHttpServer` per il monitoraggio dei parametri dei plugin è attivo per impostazione predefinita. Per disattivarlo, cambia la terza riga del comando in `FluentBitHttpPort=''` (stringa vuota) nel comando.
Inoltre, per impostazione predefinita, Fluent Bit legge i file di log dalla coda e acquisisce solo i nuovi log dopo che è stato implementato. Se avere l'effetto contrario, imposta `FluentBitReadFromHead='On'` e raccoglierà tutti i log nel file system.
1. Scarica e implementa il daemonset Fluent BIt nel cluster eseguendo uno dei seguenti comandi.
+ Se desideri la configurazione Fluent Bit ottimizzata per computer con Linux, esegui questo comando.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/fluent-bit/fluent-bit.yaml
```
+ Se desideri la configurazione Fluent Bit ottimizzata per computer con Windows, esegui questo comando.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/fluent-bit/fluent-bit-windows.yaml
```
+ Se stai utilizzando computer con Linux e desideri che la configurazione Fluent Bit sia più simile a Fluentd, esegui questo comando.
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/fluent-bit/fluent-bit-compatible.yaml
```
**Importante**
La configurazione del daemset Fluent Bit di default imposta il livello di registro su INFO, il che può comportare costi di inserimento dei CloudWatch log più elevati. Se si desidera ridurre il volume e i costi di importazione dei log, è possibile modificare il livello di registrazione in ERROR.
Per ulteriori informazioni sulla riduzione del volume di log, consulta [Riduzione del volume di log da Fluent Bit (facoltativo)](#ContainerInsights-fluentbit-volume)
1. Convalida l'implementazione immettendo il seguente comando. Ogni nodo deve avere un pod denominato **fluent-bit-\$1**.
```
kubectl get pods -n amazon-cloudwatch
```
Le fasi precedenti creano le seguenti risorse nel cluster:
+ Un account di servizio denominato `Fluent-Bit` nello spazio dei nomi `amazon-cloudwatch`. Questo account di servizio viene utilizzato per eseguire il DaemonSet Fluent Bit. Per ulteriori informazioni, consulta [Gestione degli account di servizio](https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin/) nella documentazione di riferimento di Kubernetes.
+ Un ruolo cluster denominato `Fluent-Bit-role` nello spazio dei nomi `amazon-cloudwatch`. Questo ruolo di cluster concede le autorizzazioni `get`, `list` e `watch` sui log di pod all'account di servizio `Fluent-Bit`. Per ulteriori informazioni, consulta [Panoramica delle API](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#api-overview/) nella documentazione di riferimento di Kubernetes.
+ Un nome nel namespace. ConfigMap `Fluent-Bit-config` `amazon-cloudwatch` ConfigMap Contiene la configurazione che deve essere utilizzata da Fluent Bit. Per ulteriori informazioni, consulta [Configurare un pod per utilizzare a ConfigMap nella documentazione di](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/) Kubernetes Tasks.
Se si desidera verificare la configurazione di Fluent Bit, procedi come segue.
**Verifica l'impostazione di Fluent Bit**
1. Apri la console all' CloudWatch indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Assicurati di trovarti nella regione in cui è stato implementato Fluent Bit.
1. Controlla l'elenco dei gruppi di log nella regione. Verrà visualizzato un codice analogo al seguente:
+ `/aws/containerinsights/Cluster_Name/application`
+ `/aws/containerinsights/Cluster_Name/host`
+ `/aws/containerinsights/Cluster_Name/dataplane`
1. Passa a uno di questi gruppi di log e controlla **Last Event Time** (Ora ultimo evento) per i flussi di log. Se è recente rispetto a quando è stato implementato Fluent Bit, l'installazione viene verificata.
Potrebbe esserci un leggero ritardo nella creazione del gruppo di log `/dataplane`. Questo è normale in quanto questi gruppi di log vengono creati solo quando Fluent Bit inizia a inviare i log per quel gruppo di log.
## Supporto per log multi-linea
Per informazioni su come utilizzare Fluent Bit con log multi-linea, consulta le sezioni della documentazione di Fluent Bit riportate di seguito.
+ [Multiline Parsing](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/multiline-parsing)
+ [Multiline and Containers (v1.8)](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-and-containers-v1.8)
+ [Multiline Core (v1.8)](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-core-v1.8)
+ [Always use multiline in the tail input](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#always-use-multiline-the-tail-input)
## Riduzione del volume di log da Fluent Bit (facoltativo)
Per impostazione predefinita, inviamo i log delle applicazioni Fluent Bit e i metadati Kubernetes a. CloudWatch Se desideri ridurre il volume di dati a cui inviare CloudWatch, puoi impedire l'invio a una o entrambe queste fonti di dati. CloudWatch Se hai seguito i passaggi di questa pagina per configurare Fluent Bit, scarica il file manifesto YAML di Kubernetes dal comando kubectl `apply` eseguito in precedenza, apporta le modifiche necessarie e riapplicalo al cluster. In alternativa, se utilizzi il componente aggiuntivo Amazon CloudWatch Observability EKS o il grafico Helm, consulta [(Facoltativo) Configurazione aggiuntiva](install-CloudWatch-Observability-EKS-addon.md#install-CloudWatch-Observability-EKS-addon-configuration) per informazioni sulla gestione della configurazione Fluent Bit utilizzando la configurazione avanzata del componente aggiuntivo o il diagramma Helm.
Per arrestare i log dell'applicazione Fluent Bit, rimuovi la sezione seguente dal file `Fluent Bit configuration`.
```
[INPUT]
Name tail
Tag application.*
Path /var/log/containers/fluent-bit*
Parser docker
DB /fluent-bit/state/flb_log.db
Mem_Buf_Limit 5MB
Skip_Long_Lines On
Refresh_Interval 10
```
Per evitare che i metadati Kubernetes vengano aggiunti agli eventi di registro a cui vengono inviati CloudWatch, aggiungi i seguenti filtri alla sezione della configurazione Fluent Bit. `application-log.conf` Sostituisci ** e i campi simili con gli identificatori di metadati effettivi.
```
application-log.conf: |
[FILTER]
Name nest
Match application.*
Operation lift
Nested_under kubernetes
Add_prefix Kube.
[FILTER]
Name modify
Match application.*
Remove Kube.
Remove Kube.
Remove Kube.
[FILTER]
Name nest
Match application.*
Operation nest
Wildcard Kube.*
Nested_under kubernetes
Remove_prefix Kube.
```
## Risoluzione dei problemi
Se non visualizzi questi gruppi di log e stai controllando nella regione corretta, controllare i log per i pod daemonSet Fluent Bit per individuare l'errore.
Esegui il comando seguente e accertati che lo stato sia `Running`.
```
kubectl get pods -n amazon-cloudwatch
```
Se i log contengono errori correlati alle autorizzazioni IAM, controlla il ruolo IAM collegato ai nodi del cluster. Per ulteriori informazioni sulle autorizzazioni necessarie per l'esecuzione di un cluster Amazon EKS, consulta [Policy, ruoli e autorizzazioni IAM di Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/IAM_policies.html) nella *Guida per l'utente Amazon EKS*.
Se lo stato del pod è `CreateContainerConfigError`, ottieni l'errore preciso eseguendo il seguente comando.
```
kubectl describe pod pod_name -n amazon-cloudwatch
```
## Pannello di controllo
Puoi creare un pannello di controllo per monitorare i parametri di ciascun plug-in in esecuzione. È possibile visualizzare i dati per i byte di input e output e per le velocità di elaborazione record, nonché gli errori e le frequenze di output. retry/failed Per visualizzare questi parametri, dovrai installare l' CloudWatch agente con la raccolta di metriche Prometheus per i cluster Amazon EKS e Kubernetes. Per ulteriori informazioni su come configurare il pannello di controllo, consulta [Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e KubernetesInstalla l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Setup.md).
**Nota**
Prima di configurare questo pannello di controllo, è necessario impostare Container Insights per i parametri Prometheus. Per ulteriori informazioni, consulta la pagina [Monitoraggio dei parametri di Container Insights Prometheus](ContainerInsights-Prometheus.md).
**Per creare un pannello di controllo per i parametri Prometheus di Fluent Bit**
1. Crea variabili di ambiente, sostituendo i valori a destra nelle righe seguenti in modo che corrispondano all'implementazione.
```
DASHBOARD_NAME=your_cw_dashboard_name
REGION_NAME=your_metric_region_such_as_us-west-1
CLUSTER_NAME=your_kubernetes_cluster_name
```
1. Crea il pannello di controllo eseguendo il comando seguente.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/fluent-bit/cw_dashboard_fluent_bit.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --dashboard-body
```
# (Facoltativo) Impostare la registrazione del piano di controllo Amazon EKS
Se utilizzi Amazon EKS, puoi facoltativamente abilitare la registrazione del piano di controllo di Amazon EKS, per fornire log di audit e diagnostica direttamente dal piano di controllo di Amazon EKS a Logs. CloudWatch Per ulteriori informazioni, consulta [Registrazione del piano di controllo Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html).
# (Facoltativo) Abilitazione di funzione Use\$1Kubelet per cluster di grandi dimensioni
Per impostazione predefinita, la funzionalità Use\$1Kubelet è disabilitata nel plug-in Kubernetes. FluentBit L'abilitazione di questa funzione può ridurre il traffico verso il server API e mitigare il problema che il server API è un collo di bottiglia. Ti consigliamo di abilitare questa funzione per cluster di grandi dimensioni.
Per abilitare Use\$1Kubelet, aggiungi prima i nodi e le autorizzazioni alla configurazione ClusterRole. nodes/proxy
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: fluent-bit-role
rules:
- nonResourceURLs:
- /metrics
verbs:
- get
- apiGroups: [""]
resources:
- namespaces
- pods
- pods/logs
- nodes
- nodes/proxy
verbs: ["get", "list", "watch"]
```
Nella DaemonSet configurazione, questa funzionalità richiede l'accesso alla rete host. La versione dell'immagine per `amazon/aws-for-fluent-bit` dovrebbe 2.12.0 o successiva, oppure la versione dell'immagine bit fluent dovrebbe essere 1.7.2 o successiva.
```
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: fluent-bit
namespace: amazon-cloudwatch
labels:
k8s-app: fluent-bit
version: v1
kubernetes.io/cluster-service: "true"
spec:
selector:
matchLabels:
k8s-app: fluent-bit
template:
metadata:
labels:
k8s-app: fluent-bit
version: v1
kubernetes.io/cluster-service: "true"
spec:
containers:
- name: fluent-bit
image: amazon/aws-for-fluent-bit:2.19.0
imagePullPolicy: Always
env:
- name: AWS_REGION
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: logs.region
- name: CLUSTER_NAME
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: cluster.name
- name: HTTP_SERVER
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: http.server
- name: HTTP_PORT
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: http.port
- name: READ_FROM_HEAD
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: read.head
- name: READ_FROM_TAIL
valueFrom:
configMapKeyRef:
name: fluent-bit-cluster-info
key: read.tail
- name: HOST_NAME
valueFrom:
fieldRef:
fieldPath: spec.nodeName
- name: HOSTNAME
valueFrom:
fieldRef:
apiVersion: v1
fieldPath: metadata.name
- name: CI_VERSION
value: "k8s/1.3.8"
resources:
limits:
memory: 200Mi
requests:
cpu: 500m
memory: 100Mi
volumeMounts:
# Please don't change below read-only permissions
- name: fluentbitstate
mountPath: /var/fluent-bit/state
- name: varlog
mountPath: /var/log
readOnly: true
- name: varlibdockercontainers
mountPath: /var/lib/docker/containers
readOnly: true
- name: fluent-bit-config
mountPath: /fluent-bit/etc/
- name: runlogjournal
mountPath: /run/log/journal
readOnly: true
- name: dmesg
mountPath: /var/log/dmesg
readOnly: true
terminationGracePeriodSeconds: 10
hostNetwork: true
dnsPolicy: ClusterFirstWithHostNet
volumes:
- name: fluentbitstate
hostPath:
path: /var/fluent-bit/state
- name: varlog
hostPath:
path: /var/log
- name: varlibdockercontainers
hostPath:
path: /var/lib/docker/containers
- name: fluent-bit-config
configMap:
name: fluent-bit-config
- name: runlogjournal
hostPath:
path: /run/log/journal
- name: dmesg
hostPath:
path: /var/log/dmesg
serviceAccountName: fluent-bit
tolerations:
- key: node-role.kubernetes.io/master
operator: Exists
effect: NoSchedule
- operator: "Exists"
effect: "NoExecute"
- operator: "Exists"
effect: "NoSchedule"
```
La configurazione del plug-in Kubernetes dovrebbe essere simile alla seguente:
```
[FILTER]
Name kubernetes
Match application.*
Kube_URL https://kubernetes.default.svc:443
Kube_Tag_Prefix application.var.log.containers.
Merge_Log On
Merge_Log_Key log_processed
K8S-Logging.Parser On
K8S-Logging.Exclude Off
Labels Off
Annotations Off
Use_Kubelet On
Kubelet_Port 10250
Buffer_Size 0
```
# Aggiornamento o eliminazione di Container Insights su Amazon EKS e Kubernetes
Utilizza i passaggi descritti in queste sezioni per aggiornare l'immagine del contenitore dell' CloudWatch agente o per rimuovere Container Insights da un cluster Amazon EKS o Kubernetes.
**Topics**
+ [Aggiornamento a Container Insights con osservabilità migliorata per Amazon EKS in CloudWatch](Container-Insights-upgrade-enhanced.md)
+ [Aggiornamento dell'immagine del contenitore dell' CloudWatch agente](ContainerInsights-update-image.md)
+ [Eliminazione dell' CloudWatch agente e di Fluent Bit for Container Insights](ContainerInsights-delete-agent.md)
# Aggiornamento a Container Insights con osservabilità migliorata per Amazon EKS in CloudWatch
**Importante**
Se stai aggiornando o installando Container Insights su un cluster Amazon EKS, ti consigliamo di utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS per l'installazione, anziché seguire le istruzioni in questa sezione. Inoltre, per recuperare i parametri di elaborazione accelerata, devi utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS. Per ulteriori informazioni e istruzioni, consulta [Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS](Container-Insights-setup-EKS-addon.md).
Approfondimenti sui container con osservabilità migliorata per Amazon EKS è la versione più recente di Approfondimenti sui container. Raccoglie parametri dettagliati dai cluster che eseguono Amazon EKS e offre pannelli di controllo accurati e immediatamente utilizzabili per approfondire la telemetria delle applicazioni e dell'infrastruttura. Per ulteriori informazioni su questa versione di Approfondimenti sui container, consulta la pagina [Container Insights con osservabilità migliorata per Amazon EKS](container-insights-detailed-metrics.md).
Se hai installato la versione originale di Approfondimenti sui container su un cluster Amazon EKS e desideri aggiornarla alla versione più recente con osservabilità migliorata, segui le istruzioni riportate in questa sezione.
**Importante**
Prima di completare la procedura descritta in questa sezione, è necessario verificare i prerequisiti, incluso cert-manager. Per ulteriori informazioni, consulta [Avvio rapido con l'operatore CloudWatch agente e Fluent Bit](Container-Insights-setup-EKS-quickstart.md#Container-Insights-setup-EKS-quickstart-FluentBit).
**Aggiornamento di un cluster Amazon EKS ad Approfondimenti sui container con osservabilità migliorata per Amazon EKS**
1. Installa l'operatore dell' CloudWatch agente inserendo il seguente comando. Sostituisci *my-cluster-name* con il nome del tuo cluster Amazon EKS o Kubernetes e sostituiscilo *my-cluster-region* con il nome della regione in cui vengono pubblicati i log. Ti consigliamo di utilizzare la stessa regione in cui è distribuito il cluster per ridurre i costi di trasferimento dei AWS dati in uscita.
```
ClusterName=my-cluster-name
RegionName=my-cluster-region
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-operator-rendered.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/g;s/{{region_name}}/'${RegionName}'/g' | kubectl apply -f -
```
Se si nota un errore causato da un conflitto di risorse, è probabile che sul cluster siano già ClusterRoleBinding installati l' CloudWatch agente e Fluent Bit con i relativi componenti associati, ad esempio ServiceAccount, il ClusterRole e il. Quando l'operatore dell' CloudWatch agente tenta di installare l' CloudWatch agente e i componenti associati, se rileva modifiche nei contenuti, per impostazione predefinita fallisce l'installazione o l'aggiornamento per evitare di sovrascrivere lo stato delle risorse sul cluster. Si consiglia di eliminare qualsiasi CloudWatch agente esistente con la configurazione di Container Insights precedentemente installato sul cluster e quindi di installare l' CloudWatch operatore dell'agente.
1. (Facoltativo) Per applicare una configurazione Fluent Bit personalizzata esistente, è necessario aggiornare la configmap associata al daemonset Fluent Bit. L'operatore dell' CloudWatch agente fornisce una configurazione predefinita per Fluent Bit ed è possibile sovrascrivere o modificare la configurazione predefinita in base alle esigenze. Per applicare una configurazione personalizzata, segui questi passaggi.
1. Apri la configurazione esistente immettendo il seguente comando.
```
kubectl edit cm fluent-bit-config -n amazon-cloudwatch
```
1. Apporta le modifiche necessarie al file, quindi digita `:wq` per salvare il file e uscire dalla modalità di modifica.
1. Riavvia Fluent Bit inserendo il seguente comando.
```
kubectl rollout restart ds fluent-bit -n amazon-cloudwatch
```
# Aggiornamento dell'immagine del contenitore dell' CloudWatch agente
**Importante**
Se stai aggiornando o installando Container Insights su un cluster Amazon EKS, ti consigliamo di utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS per l'installazione, anziché seguire le istruzioni in questa sezione. Inoltre, per recuperare i parametri di elaborazione accelerata, devi utilizzare il componente aggiuntivo Amazon CloudWatch Observability EKS o l'operatore dell'agente. CloudWatch Per ulteriori informazioni e istruzioni, consulta [Avvio rapido con il componente aggiuntivo Amazon CloudWatch Observability EKS](Container-Insights-setup-EKS-addon.md).
Se devi aggiornare l'immagine del container alla versione più recente, utilizza le fasi in questa sezione.
**Per aggiornare l'immagine del container**
1. Verifica se la Custom Resource Definition (CRD) `amazoncloudwatchagent` esiste già inserendo il seguente comando.
```
kubectl get crds amazoncloudwatchagents.cloudwatch.aws.amazon.com -n amazon-cloudwatch
```
Se questo comando restituisce un errore relativo alla mancanza del CRD, nel cluster non è configurato Container Insights con osservabilità avanzata per Amazon EKS con l' CloudWatch operatore agente. In questo caso, consulta [Aggiornamento a Container Insights con osservabilità migliorata per Amazon EKS in CloudWatch](Container-Insights-upgrade-enhanced.md).
1. Applica il file `cwagent-version.yaml` più recente immettendo il comando seguente.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-version.yaml | kubectl apply -f -
```
# Eliminazione dell' CloudWatch agente e di Fluent Bit for Container Insights
Se hai installato Container Insights utilizzando il componente aggiuntivo CloudWatch Observability per Amazon EKS, puoi eliminare Container Insights e l' CloudWatch agente inserendo il seguente comando:
**Nota**
Il componente aggiuntivo Amazon EKS ora supporta Container Insights sui nodi worker di Windows. Se elimini il componente aggiuntivo Amazon EKS, viene eliminato anche Container Insights per Windows.
```
aws eks delete-addon —cluster-name my-cluster —addon-name amazon-cloudwatch-observability
```
Altrimenti, per eliminare tutte le risorse relative all' CloudWatch agente e a Fluent Bit, inserisci il seguente comando. In questo comando, *My\$1Cluster\$1Name* è il nome del tuo cluster Amazon EKS o Kubernetes e *My\$1Region* il nome della regione in cui vengono pubblicati i log.
```
ClusterName=My_Cluster_Name
RegionName=My-Region
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-operator-rendered.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/g;s/{{region_name}}/'${RegionName}'/g' | kubectl delete -f -
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/main/k8s-quickstart/cwagent-custom-resource-definitions.yaml | kubectl delete -f -
```
# Configurazione di Container Insights su on RedHat OpenShift (ROSA) AWS
CloudWatch Container Insights con supporto avanzato per l'osservabilità RedHat OpenShift on AWS (ROSA). Questa versione supporta l'osservabilità migliorata per i cluster ROSA. Dopo aver installato il grafico Helm dell'operatore CloudWatch agente, Container Insights raccoglie automaticamente la telemetria dettagliata dell'infrastruttura dal livello del cluster fino al livello di contenitore nell'ambiente. Quindi visualizza questi dati sulle prestazioni in pannelli di controllo curati, eliminando il problema della configurazione dell'osservabilità.
**Nota**
Per RedHat for OpenShift on AWS (ROSA), quando si installa l'operatore dell' CloudWatch agente utilizzando helm chart, per impostazione predefinita l' CloudWatch agente è inoltre abilitato a ricevere sia le metriche che le tracce dalle applicazioni che sono strumentate per Application Signals. Se desideri inoltrare facoltativamente regole di configurazione personalizzate, puoi farlo inoltrando una configurazione dell'agente personalizzata al grafico Helm, come indicato in (Facoltativo) [Additional configuration], come indicato su [(Facoltativo) Configurazione aggiuntiva](install-CloudWatch-Observability-EKS-addon.md#install-CloudWatch-Observability-EKS-addon-configuration).
**Per installare Container Insights con una migliore osservabilità su un RedHat OpenShift cluster on (ROSA) AWS**
1. Se necessario, installa Helm. Per ulteriori informazioni, consulta la [Guida rapida](https://helm.sh/docs/intro/quickstart/) nella documentazione di Helm.
1. Installa l'operatore dell' CloudWatch agente inserendo i seguenti comandi. Sostituiscilo *my-cluster-name* con il nome del cluster e *my-cluster-region* sostituiscilo con la regione in cui viene eseguito il cluster.
```
helm repo add aws-observability https://aws-observability.github.io/helm-charts
helm repo update aws-observability
helm install --wait --create-namespace \
--namespace amazon-cloudwatch amazon-cloudwatch-observability \
aws-observability/amazon-cloudwatch-observability \
--set clusterName=my-cluster-name \
--set region=my-cluster-region \
--set k8sMode=ROSA
```
1. Imposta l'autorizzazione per l'operatore dell'agente seguendo i passaggi indicati nell'Opzione 1, Opzione 2 o Opzione 3 in [Installa l' CloudWatch agente con il componente aggiuntivo Amazon CloudWatch Observability EKS o il grafico Helm](install-CloudWatch-Observability-EKS-addon.md).