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à.
# Monitoraggio dei parametri di Container Insights Prometheus
CloudWatch Il monitoraggio di Container Insights per Prometheus automatizza la scoperta delle metriche di Prometheus da sistemi e carichi di lavoro containerizzati. Prometheus è un kit di strumenti di monitoraggio e avvisi di sistema open source. Per ulteriori informazioni, vedere [ Che cos'è Prometheus?](https://prometheus.io/docs/introduction/overview/) nella documentazione di Prometheus.
L'individuazione dei parametri Prometheus è supportata per cluster [Amazon Elastic Container Service](https://aws.amazon.com/ecs/), [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/) e [Kubernetes](https://aws.amazon.com/kubernetes/) in esecuzione su istanze Amazon EC2. Vengono raccolti i tipi di parametri misuratore, contatore e riepilogo di Prometheus.
Per i cluster Amazon ECS e Amazon EKS, sono supportati sia i tipi di avvio EC2 che Fargate. Container Insights raccoglie automaticamente i parametri da diversi carichi di lavoro ed è possibile configurarlo per raccogliere parametir da qualsiasi carico di lavoro.
Puoi adottare Prometheus come metodo open source e open standard per inserire metriche personalizzate in CloudWatch. L' CloudWatch agente con supporto Prometheus rileva e raccoglie le metriche di Prometheus per monitorare, risolvere i problemi e segnalare più rapidamente il degrado delle prestazioni e i guasti delle applicazioni. Ciò riduce anche il numero di strumenti di monitoraggio necessari per migliorare l'osservabilità.
Il supporto di Container Insights Prometheus pay-per-use include metriche e log, tra cui la raccolta, l'archiviazione e l'analisi. Per ulteriori informazioni, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Pannelli di controllo predefiniti per alcuni carichi di lavoro**
La soluzione Container Insights Prometheus include pannelli di controllo predefiniti per i carichi di lavoro più diffusi elencati in questa sezione. Per configurazioni di esempio per questi carichi di lavoro, consulta [(Facoltativo) Impostazione dei carichi di lavoro Amazon ECS containerizzati di esempio per i test dei parametri di Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md) e [(Facoltativo) Impostazione dei carichi di lavoro Amazon EKS containerizzati di esempio per i test dei parametri di Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md).
È inoltre possibile configurare Container Insights per raccogliere parametri Prometheus da altri servizi e applicazioni containerizzati modificando il file di configurazione dell'agente.
Carichi di lavoro con pannelli di controllo predefiniti per cluster Amazon EKS e cluster Kubernetes in esecuzione su istanze Amazon EC2:
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
Carichi di lavoro con pannelli di controllo predefiniti per cluster Amazon ECS:
+ AWS App Mesh
+ Java/JMX
+ NGINX
+ NGINX Plus
# Configurare e configurare la raccolta dei parametri Prometheus su cluster Amazon ECS
Per raccogliere i parametri di Prometheus dai cluster Amazon ECS, puoi CloudWatch utilizzare l'agente come raccoglitore o utilizzare Distro for collector. AWS OpenTelemetry [Per informazioni sull'utilizzo di Distro for collector, consulta https://aws-otel.github. AWS OpenTelemetry io/docs/getting-started/container-insights/ecs-prometeo.](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus)
Le sezioni seguenti spiegano come utilizzare l' CloudWatch agente come raccoglitore per recuperare le metriche di Prometheus. Installa l' CloudWatch agente con il monitoraggio Prometheus su cluster che eseguono Amazon ECS e, facoltativamente, puoi configurare l'agente per acquisire obiettivi aggiuntivi. Queste sezioni offrono inoltre esercitazioni facoltative per l'impostazione di carichi di lavoro di esempio da utilizzare per i test con il monitoraggio Prometheus.
Container Insights su Amazon ECS supporta le seguenti combinazioni di modalità di avvio e modalità di rete per i parametri Prometheus:
| Tipo di avvio di Amazon ECS | Modalità di rete supportate |
| --- | --- |
| EC2 (Linux) | bridge, host e awsvpc |
| Fargate | awsvpc |
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
**Topics**
+ [Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon ECS](ContainerInsights-Prometheus-install-ECS.md)
+ [Scraping di ulteriori origini Prometheus e importazione di tali parametri](ContainerInsights-Prometheus-Setup-configure-ECS.md)
+ [(Facoltativo) Impostazione dei carichi di lavoro Amazon ECS containerizzati di esempio per i test dei parametri di Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)
# Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon ECS
Questa sezione spiega come configurare l' CloudWatch agente con il monitoraggio Prometheus in un cluster che esegue Amazon ECS. Dopo aver eseguito questa operazione, l'agente esegue automaticamente lo scraping e l'importazione dei parametri per i seguenti carichi di lavoro in esecuzione in quel cluster.
+ AWS App Mesh
+ Java/JMX
È inoltre possibile configurare l'agente per recuperare e importare parametri da altri carichi di lavoro e origini Prometheus.
## Configurazione di ruoli IAM
Sono necessari due ruoli IAM per la definizione delle attività dell'agente. CloudWatch Se specifichi **CreateIAMRoles=True** nello CloudFormation stack che Container Insights crei questi ruoli per te, i ruoli verranno creati con le autorizzazioni corrette. Se si desidera crearli personalmente o utilizzare ruoli esistenti, sono necessari i seguenti ruoli e autorizzazioni.
+ **CloudWatch ruolo dell'agente ECS: il** contenitore dell' CloudWatchagente utilizza questo ruolo. Deve includere la **CloudWatchAgentServerPolicy**policy e una policy gestita dal cliente che contenga le seguenti autorizzazioni di sola lettura:
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:ListServices`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeServices`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
+ **CloudWatch ruolo di esecuzione delle attività ECS dell'agente**: questo è il ruolo richiesto da Amazon ECS per avviare ed eseguire i container. Assicurati che al tuo ruolo di esecuzione delle attività siano associati **Amazon SSMRead OnlyAccess ECSTask** **ExecutionRolePolicy, Amazon** e **CloudWatchAgentServerPolicy**le policy. Se si desidera archiviare dati più riservati utilizzabili da Amazon ECS, consulta [Specifica dei dati sensibili](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) per ulteriori informazioni.
## Installa l' CloudWatch agente con il monitoraggio Prometheus utilizzando CloudFormation
Lo usi AWS CloudFormation per installare l' CloudWatch agente con il monitoraggio Prometheus per i cluster Amazon ECS. L'elenco seguente mostra i parametri che verranno utilizzati nel modello CloudFormation .
+ **ECSClusterNome**: specifica il cluster Amazon ECS di destinazione.
+ **Crea IAMRoles**: specifica **True** di creare nuovi ruoli per il ruolo di attività di Amazon ECS e il ruolo di esecuzione del compito di Amazon ECS. Specifica **False** per riutilizzare i ruoli esistenti.
+ **TaskRoleName**— Se hai specificato **True** **Create IAMRoles**, questo specifica il nome da utilizzare per il nuovo task role di Amazon ECS. Se hai specificato **False** **Create IAMRoles**, questo specifica il ruolo esistente da utilizzare come task role di Amazon ECS.
+ **ExecutionRoleName**— Se hai specificato **True** **Create IAMRoles**, questo specifica il nome da utilizzare per il nuovo ruolo di esecuzione delle attività di Amazon ECS. Se hai specificato **False** **Create IAMRoles**, questo specifica il ruolo esistente da utilizzare come ruolo di esecuzione delle attività di Amazon ECS.
+ **ECSNetworkModalità**: se utilizzi il tipo di avvio EC2, specifica qui la modalità di rete. Deve essere **bridge** o **host**.
+ **ECSLaunchTipo**: specifica **fargate** o**EC2**.
+ **SecurityGroupID**: se la **ECSNetworkmodalità** è**awsvpc**, specifica qui l'ID del gruppo di sicurezza.
+ **SubnetID**: se la **ECSNetworkmodalità** è**awsvpc**, specifica qui l'ID della sottorete.
### Comandi di esempio
Questa sezione include CloudFormation comandi di esempio per installare Container Insights con il monitoraggio Prometheus in vari scenari.
**Crea uno CloudFormation stack per un cluster Amazon ECS in modalità di rete bridge**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=bridge
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Crea uno CloudFormation stack per un cluster Amazon ECS in modalità rete host**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=host
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Crea uno CloudFormation stack per un cluster Amazon ECS in modalità di rete awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=EC2
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Crea uno CloudFormation stack per un cluster Fargate in modalità di rete awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=FARGATE
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
### AWS risorse create dallo stack CloudFormation
La tabella seguente elenca le AWS risorse che vengono create quando si utilizza CloudFormation per configurare il monitoraggio di Container Insights con Prometheus su un cluster Amazon ECS.
| Tipo di risorsa | Nome risorsa | Commenti |
| --- | --- | --- |
| AWS::SSM::Parameter | AmazonCloudWatch- CWAgent Config-\$1 -\$1 -\$1 *ECS\$1CLUSTER\$1NAME* *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE* | Questo è l' CloudWatch agente con l'App Mesh predefinita e la definizione del formato metrico Java/JMX incorporato. |
| AWS::SSM::Parameter | AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Questa è la configurazione di scraping di Prometheus. |
| AWS::IAM::Role | **\$1ECS\$1TASK\$1ROLE\$1NAME**. | Il ruolo dell'attività di Amazon ECS. Questo viene creato solo se è stato specificato **True** per `CREATE_IAM_ROLES`. |
| AWS::IAM::Role | **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1** | Ruolo per l'esecuzione dell'attività Amazon ECS. Questo viene creato solo se è stato specificato **True** per `CREATE_IAM_ROLES`. |
| AWS::ECS::TaskDefinition | cwagent-prometheus-\$1 *ECS\$1CLUSTER\$1NAME* -\$1 *ECS\$1LAUNCH\$1TYPE* *ECS\$1NETWORK\$1MODE* | |
| AWS::ECS::Service | cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
### Eliminazione dello CloudFormation stack per l' CloudWatch agente con il monitoraggio di Prometheus
Per eliminare l' CloudWatch agente da un cluster Amazon ECS, inserisci questi comandi.
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name
aws cloudformation delete-stack \
--stack-name ${CLOUDFORMATION_STACK_NAME} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Scraping di ulteriori origini Prometheus e importazione di tali parametri
L' CloudWatch agente con monitoraggio Prometheus necessita di due configurazioni per analizzare le metriche di Prometheus. Una è per le configurazioni standard Prometheus come documentato in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) nella documentazione di Prometheus. L'altra è per la configurazione dell'agente. CloudWatch
Per i cluster Amazon ECS, le configurazioni sono integrate con il Parameter Store di AWS Systems Manager dai segreti nella definizione dell'attività Amazon ECS:
+ Il segreto `PROMETHEUS_CONFIG_CONTENT` è per la configurazione di scraping di Prometheus.
+ Il segreto `CW_CONFIG_CONTENT` è la configurazione CloudWatch dell'agente.
Per acquisire ulteriori fonti di metriche Prometheus e importare tali metriche in, è necessario modificare sia la configurazione dello scrape di Prometheus che la configurazione dell'agente, quindi ridistribuire l'agente con la configurazione aggiornata. CloudWatch CloudWatch
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
## Configurazione di Prometheus Scrape
L' CloudWatch agente supporta le configurazioni scrape standard di Prometheus come documentato nella documentazione di Prometheus.[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) È possibile modificare questa sezione per aggiornare le configurazioni già presenti in questo file e aggiungere ulteriori destinazioni di scraping Prometheus. Per impostazione predefinita, il file di configurazione campione contiene le seguenti righe di configurazione globali:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval**: definisce con quale frequenza recuperare le destinazioni.
+ **scrape\$1timeout**: definisce quanto tempo attendere prima che una richiesta di scrape scada.
È inoltre possibile definire valori diversi per queste impostazioni a livello di processo, per ignorare le configurazioni globali.
### Attività di scraping di Prometheus
Nei file YAML dell' CloudWatch agente sono già configurati alcuni processi di scraping predefiniti. Ad esempio, nei file YAML per Amazon ECS ad esempio `cwagent-ecs-prometheus-metric-for-bridge-host.yaml`, i processi di scraping predefiniti sono configurati nella sezione `ecs_service_discovery`.
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
},
"task_definition_list": [
{
"sd_job_name": "ecs-appmesh-colors",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+",
"sd_metrics_path": "/stats/prometheus"
},
{
"sd_job_name": "ecs-appmesh-gateway",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+",
"sd_metrics_path": "/stats/prometheus"
}
]
}
```
Ciascuno di questi obiettivi predefiniti viene eliminato e le metriche vengono inviate agli eventi di registro utilizzando il formato CloudWatch metrico incorporato. Per ulteriori informazioni, consulta [Incorporamento dei parametri nei log](CloudWatch_Embedded_Metric_Format.md).
Gli eventi di log dei cluster Amazon ECS vengono archiviati nel gruppo di log**/aws/ecs/containerinsights/*cluster\$1name*/prometheus.**
Ogni processo di scraping è contenuto in un flusso di log diverso in questo gruppo di log.
Per aggiungere una nuova destinazione di scraping, aggiungi una nuova voce nella sezione `task_definition_list` alla sezione `ecs_service_discovery` del file YAML e riavvia l'agente. Per un esempio di questo processo, vedere [Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).
## CloudWatch configurazione dell'agente per Prometheus
Il file di configurazione CloudWatch dell'agente ha una `prometheus` sezione sotto `metrics_collected` per la configurazione dello scraping di Prometheus. Include le opzioni di configurazione seguenti:
+ **cluster\$1name**: specifica il nome del cluster da aggiungere come etichetta nell'evento log. Questo campo è facoltativo. Se lo ometti, l'agente può rilevare il nome del cluster Amazon ECS.
+ **log\$1group\$1name**: specifica il nome del gruppo di log per i parametri Prometheus sottoposti a scraping. Questo campo è facoltativo. Se lo CloudWatch ometti, utilizza**/aws/ecs/containerinsights/*cluster\$1name*/prometheus per i log dei cluster Amazon** ECS.
+ **prometheus\$1config\$1path**: specifica il percorso del file di configurazione di scraping di Prometheus. Se il valore di questo campo inizia con `env:`, il contenuto del file di configurazione di scraping di Prometheus verrà recuperato dalla variabile di ambiente del container. Non modificare questo campo.
+ **ecs\$1service\$1discovery**: è la sezione per specificare le configurazioni delle funzioni di individuazione automatica delle destinazioni di Amazon ECS Prometheus. Sono supportate due modalità per individuare le destinazioni Prometheus: individuazione basata sull'etichetta Docker del container o individuazione basata sull'espressione regolare dell'ARN della definizione dell'attività di Amazon ECS. Puoi utilizzare le due modalità insieme e l' CloudWatchagente deduplicherà gli obiettivi rilevati in base a: *\$1private\$1ip\$1: \$1port\$1/\$1*metrics\$1path\$1.
La sezione `ecs_service_discovery` può contenere i seguenti campi:
+ `sd_frequency` è la frequenza di individuazione degli elementi di esportazione di Prometheus. Specifica un numero e un suffisso di unità. Ad esempio, `1m` per una volta al minuto o `30s` per una volta ogni 30 secondi. I suffissi di unità validi sono `ns`, `us`, `ms`, `s`, `m` e `h`.
Questo campo è facoltativo. Il valore predefinito è 60 secondi (1 minuto).
+ `sd_target_cluster` è il nome del cluster Amazon ECS di destinazione per l'individuazione automatica. Questo campo è facoltativo. L'impostazione predefinita è il nome del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_cluster_region` è la regione del cluster Amazon ECS di destinazione. Questo campo è facoltativo. L'impostazione predefinita è la regione del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_result_file` è il percorso del file YAML per i risultati di destinazione di Prometheus. La configurazione di scraping di Prometheus farà riferimento a questo file.
+ `docker_label` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati su etichette Docker. Se ometti questa sezione, l'individuazione basata sull'etichetta Docker non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_port_label` è il nome dell'etichetta Docker del container che specifica la porta del container per i parametri Prometheus. Il valore predefinito è `ECS_PROMETHEUS_EXPORTER_PORT`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente la salterà.
+ `sd_metrics_path_label` è il nome dell'etichetta Docker del container che specifica il percorso dei parametri di Prometheus. Il valore predefinito è `ECS_PROMETHEUS_METRICS_PATH`. Se il container non dispone di questa etichetta Docker, l'agente assume il percorso predefinito `/metrics`.
+ `sd_job_name_label` è il nome dell'etichetta Docker del container che specifica il nome del processo di scraping di Prometheus. Il valore predefinito è `job`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ `task_definition_list` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati sulla definizione dell'attività. Se ometti questa sezione, l'individuazione basata sulla definizione dell'attività non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_task_definition_arn_pattern` è il modello da utilizzare per specificare le definizioni delle attività Amazon ECS da individuare. Questa è un'espressione regolare.
+ `sd_metrics_ports` elenca gli elementi containerPort per i parametri di Prometheus. Separa gli elementi containerPort con il punto e virgola.
+ `sd_container_name_pattern` specifica i nomi dei container dell'attività di Amazon ECS. Questa è un'espressione regolare.
+ `sd_metrics_path` specifica il percorso del parametro Prometheus. Se ometti questa opzione, l'agente assume il percorso predefinito `/metrics`
+ `sd_job_name` specifica il nome del processo di scraping di Prometheus. Se si omette questo campo, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ `service_name_list_for_tasks` è una sezione facoltativa che puoi utilizzare per specificare la configurazione per l'individuazione basata sul nome del servizio. Se ometti questa sezione, l'individuazione basata sul nome del servizio non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_service_name_pattern` è il modello da utilizzare per specificare il servizio Amazon ECS in cui si trovano le attività da individuare. Questa è un'espressione regolare.
+ `sd_metrics_ports` Elenca gli elementi `containerPort` per i parametri Prometheus. Separa più elementi `containerPorts` con punto e virgola.
+ `sd_container_name_pattern` specifica i nomi dei container dell'attività di Amazon ECS. Questa è un'espressione regolare.
+ `sd_metrics_path` specifica il percorso dei parametri Prometheus. Se ometti questa opzione, l'agente presume che il percorso predefinito è `/metrics`.
+ `sd_job_name` specifica il nome del processo di scraping di Prometheus. Se si omette questo campo, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ **metric\$1declaration**: sono sezioni che specificano la matrice di log con formato metrico incorporato da generare. Esistono sezioni `metric_declaration` per ogni origine Prometheus da cui l'agente CloudWatch importa per impostazione predefinita. Ciascuna di queste sezioni include i seguenti campi:
+ `label_matcher` è un'espressione regolare che controlla il valore delle etichette elencate in `source_labels`. Le metriche corrispondenti sono abilitate per l'inclusione nel formato metrico incorporato inviato a. CloudWatch
Se sono state specificate più etichette in `source_labels`, ti consigliamo di non utilizzare `^` o caratteri `$` nell'espressione regolare per `label_matcher`.
+ `source_labels` specifica il valore delle etichette controllate dalla riga `label_matcher`.
+ `label_separator` specifica il separatore da utilizzare nella riga ` label_matcher` se sono specificati `source_labels` multipli. Il valore predefinito è `;`. È possibile visualizzare questo valore predefinito utilizzato nella riga `label_matcher` nell'esempio seguente.
+ `metric_selectors` è un'espressione regolare che specifica le metriche da raccogliere e inviare a CloudWatch.
+ `dimensions` è l'elenco delle etichette da utilizzare come dimensioni CloudWatch per ogni metrica selezionata.
Guarda l'esempio `metric_declaration` che segue.
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system$",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
In questo esempio viene configurata una sezione di formato metrica incorporata da inviare come evento di log se sono soddisfatte le seguenti condizioni:
+ Il valore di `Service` contiene `node-exporter` o `kube-dns`.
+ Il valore di `Namespace` è `kube-system`.
+ La metrica Prometheus `coredns_dns_request_type_count_total` contiene le etichette sia `Service` che `Namespace`.
L'evento di log inviato include la seguente sezione evidenziata:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
# Guida dettagliata per l'individuazione automatica dei cluster Amazon ECS
Prometheus offre dozzine di meccanismi dinamici di individuazione dei servizi, come descritto in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config). Tuttavia, non esiste un rilevamento dei servizi integrato per Amazon ECS. L' CloudWatch agente aggiunge questo meccanismo.
Quando il rilevamento del servizio Amazon ECS Prometheus è abilitato, l'agente effettua periodicamente CloudWatch le seguenti chiamate API ai frontend Amazon ECS e Amazon EC2 per recuperare i metadati delle attività ECS in esecuzione nel cluster ECS di destinazione.
```
EC2:DescribeInstances
ECS:ListTasks
ECS:ListServices
ECS:DescribeContainerInstances
ECS:DescribeServices
ECS:DescribeTasks
ECS:DescribeTaskDefinition
```
I metadati vengono utilizzati dall' CloudWatch agente per scansionare i target Prometheus all'interno del cluster ECS. L' CloudWatch agente supporta tre modalità di rilevamento dei servizi:
+ Individuazione del servizio basata sull'etichetta Docker del container
+ Individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS
+ Individuazione del servizio basato su espressioni regolari del nome del servizio ECS
Tutte le modalità possono essere utilizzate insieme. CloudWatch l'agente deduplica gli obiettivi rilevati in base a:. `{private_ip}:{port}/{metrics_path}`
Tutte le destinazioni rilevate vengono scritte in un file di risultati specificato dal campo di `sd_result_file` configurazione all'interno del contenitore dell' CloudWatch agente. Di seguito è riportato un file di esempio:
```
- targets:
- 10.6.1.95:32785
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT: "9406"
ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port
TaskGroup: family:demo-jar-ec2-bridge-dynamic-port
TaskRevision: "7"
VpcId: vpc-01234567890
container_name: demo-jar-ec2-bridge-dynamic-port
job: demo-jar-ec2-bridge-dynamic
- targets:
- 10.6.3.193:9404
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404"
ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port
TaskGroup: family:demo-jar-tomcat-bridge-mapped-port
TaskRevision: "12"
VpcId: vpc-01234567890
container_name: demo-tomcat-ec2-bridge-mapped-port
job: demo-tomcat-ec2-bridge-mapped-port
```
Puoi integrare direttamente questo file di risultati con l'individuazione dei servizi basata su file Prometheus. Per ulteriori informazioni sull'individuazione dei servizi basata su file Prometheus, consulta [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config).
Supponiamo che il file dei risultati sia scritto su `/tmp/cwagent_ecs_auto_sd.yaml`. La seguente configurazione di scraping Prometheus lo consumerà.
```
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: cwagent-ecs-file-sd-config
sample_limit: 10000
file_sd_configs:
- files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ]
```
L' CloudWatch agente aggiunge anche le seguenti etichette aggiuntive per le destinazioni scoperte.
+ `container_name`
+ `TaskDefinitionFamily`
+ `TaskRevision`
+ `TaskGroup`
+ `StartedBy`
+ `LaunchType`
+ `job`
+ `__metrics_path__`
+ Etichette Docker
Quando il cluster ha il tipo di avvio EC2, vengono aggiunte le seguenti tre etichette.
+ `InstanceType`
+ `VpcId`
+ `SubnetId`
**Nota**
Le etichette Docker che non corrispondono all'espressione regolare `[a-zA-Z_][a-zA-Z0-9_]*` vengono filtrate. Questo corrisponde alle convenzioni Prometheus elencate in `label_name` in [Configuration file](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) (File di configurazione) nella documentazione di Prometheus.
## Esempi di configurazione dell'individuazione dei servizi ECS
In questa sezione sono inclusi esempi che illustrano l'individuazione dei servizi ECS.
**Esempio 1**
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
}
}
```
Questo esempio abilita l'individuazione dei servizi basata su etichette Docker. L' CloudWatch agente interrogherà i metadati delle attività ECS una volta al minuto e scriverà le destinazioni rilevate nel `/tmp/cwagent_ecs_auto_sd.yaml` file all'interno del contenitore dell'agente. CloudWatch
Il valore predefinito di `sd_port_label` nella sezione `docker_label` è `ECS_PROMETHEUS_EXPORTER_PORT`. Se un contenitore in esecuzione nelle attività ECS ha un'etichetta `ECS_PROMETHEUS_EXPORTER_PORT` docker, CloudWatch l'agente utilizza il suo valore `container port` per scansionare tutte le porte esposte del contenitore. Se esiste una corrispondenza, la porta host mappata più l'IP privato del container vengono utilizzati per costruire la destinazione dell'esportatore Prometheus nel seguente formato: `private_ip:host_port`.
Il valore predefinito di `sd_metrics_path_label` nella sezione `docker_label` è `ECS_PROMETHEUS_METRICS_PATH`. Se il container ha questa etichetta Docker, il suo valore verrà utilizzato come `__metrics_path__`. Se il container non ha questa etichetta, viene utilizzato il valore predefinito `/metrics`.
Il valore predefinito di `sd_job_name_label` nella sezione `docker_label` è `job`. Se il container ha questa etichetta Docker, il suo valore verrà aggiunto come una delle etichette per la destinazione per sostituire il nome del processo predefinito specificato nella configurazione Prometheus. Il valore di questa etichetta docker viene utilizzato come nome del flusso di log nel gruppo CloudWatch Logs log.
**Esempio 2**
```
"ecs_service_discovery": {
"sd_frequency": "15s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A",
"sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME"
}
}
```
Questo esempio abilita l'individuazione dei servizi basati su etichette docker. THe CloudWatch l'agente interrogherà i metadati delle attività ECS ogni 15 secondi e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch I container con un'etichetta Docker di `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` verranno scansionati. Il valore dell'etichetta Docker `ECS_PROMETHEUS_JOB_NAME` viene usato come nome del processo.
**Esempio 3**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"task_definition_list": [
{
"sd_job_name": "java-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9404; 9406",
"sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+"
},
{
"sd_job_name": "envoy-prometheus",
"sd_metrics_path": "/stats/prometheus",
"sd_container_name_pattern": "^envoy$",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23"
}
]
}
```
Questo esempio abilita l'individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS. L' CloudWatch agente interrogherà i metadati delle attività ECS ogni cinque minuti e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch
Sono definite due sezioni di espressione regolare dell'ARN di definizione dell'attività:
+ Per la prima sezione, le attività ECS con `javajmx` nel loro ARN di definizione dell'attività ECS vengono filtrati per la scansione della porta del container. Se i contenitori all'interno di queste attività ECS espongono la porta del container su 9404 o 9406, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/metrics`. Quindi l' CloudWatch agente estrarrà le metriche di Prometheus, le metriche eliminate verranno inviate al flusso `private_ip:host_port/metrics` di log in Logs nel gruppo di `java-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus`
+ Per la seconda sezione, le attività ECS con `appmesh` nel loro ARN di definizione dell'attività ECS e con `version` di `:23` vengono filtrati per la scansione della porta del container. Per i contenitori con il nome `envoy` che espongono la porta del container su `9901`, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare i target dell'esportatore Prometheus. Il valore all'interno di queste attività ECS espongono la porta del container su 9404 o 9406, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/stats/prometheus`. Quindi l' CloudWatch agente raccoglierà le metriche di Prometheus e le invierà al `private_ip:host_port/stats/prometheus` flusso di log in Logs nel gruppo di `envoy-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus`
**Esempio 4**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-.*"
},
{
"sd_job_name": "haproxy-prometheus",
"sd_metrics_path": "/stats/metrics",
"sd_container_name_pattern": "^haproxy$",
"sd_metrics_ports": "8404",
"sd_service_name_pattern": ".*haproxy-service.*"
}
]
}
```
Questo esempio abilita l'individuazione del servizio basata su espressioni regolari del nome del servizio ECS. L' CloudWatch agente interrogherà i metadati dei servizi ECS ogni cinque minuti e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch
Sono definite due sezioni di espressioni regolari del nome del servizio:
+ Per la prima sezione, le attività ECS associate ai servizi ECS con nomi corrispondenti all'espressione regolare `^nginx-.*` vengono filtrati per la scansione della porta del container. Se i contenitori all'interno di queste attività ECS espongono la porta del container su 9113, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/metrics`. Quindi l' CloudWatch agente estrarrà le metriche di Prometheus e le metriche eliminate `private_ip:host_port/metrics` verranno inviate al flusso di log in Logs nel gruppo di `nginx-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus`
+ o per la seconda sezione, le attività ECS associate ai servizi ECS con nomi corrispondenti all'espressione regolare `.*haproxy-service.*` vengono filtrati per la scansione della porta del container. Per i contenitori con il nome `haproxy` che espongono la porta del container su 8404, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare i target dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/stats/metrics`. Quindi l' CloudWatchagente estrarrà le metriche di Prometheus e le metriche eliminate `private_ip:host_port/stats/metrics` verranno inviate al flusso di log in Logs nel gruppo di `haproxy-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus`
**Esempio 5**
```
"ecs_service_discovery": {
"sd_frequency": "1m30s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL",
"sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL",
"sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL"
}
"task_definition_list": [
{
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": "*memcached.*"
}
]
}
```
In questo esempio vengono abilitate entrambe le modalità di individuazione dei servizi ECS. L' CloudWatch agente interrogherà i metadati delle attività ECS ogni 90 secondi e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch
Per la configurazione dell'individuazione del servizio basata su Docker:
+ Le attività ECS con etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` verranno filtrate per la scansione della porta Prometheus. La porta del container Prometheus di destinazione è specificata dal valore dell'etichetta `MY_PROMETHEUS_EXPORTER_PORT_LABEL`.
+ Il valore dell'etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` viene utilizzato per `__metrics_path__`. Se il container non ha questa etichetta Docker, viene utilizzato il valore predefinito `/metrics`.
+ Il valore dell'etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` viene usato come etichetta del processo. Se il container non dispone di questa etichetta Docker, viene utilizzato il nome del processo definito nella configurazione Prometheus.
Per la configurazione dell'individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS:
+ Le attività ECS con `memcached` nell'ARN di definizione dell'attività ECS vengono filtrati per la scansione della porta del container. La porta del container Prometheus di destinazione è 9150 come definito da `sd_metrics_ports`. Viene utilizzato il percorso dei parametri predefinito `/metrics`. Viene utilizzato il nome del processo definito nella configurazione Prometheus.
# (Facoltativo) Impostazione dei carichi di lavoro Amazon ECS containerizzati di esempio per i test dei parametri di Prometheus
Per testare il supporto delle metriche Prometheus CloudWatch in Container Insights, puoi configurare uno o più dei seguenti carichi di lavoro containerizzati. L' CloudWatch agente con supporto Prometheus raccoglie automaticamente le metriche da ciascuno di questi carichi di lavoro. Per visualizzare le metriche raccolte per impostazione predefinita, vedere [Metriche di Prometheus raccolte dall'agente CloudWatch](ContainerInsights-Prometheus-metrics.md).
**Topics**
+ [Carico di lavoro App Mesh di esempio per cluster Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md)
+ [Java/JMX Carico di lavoro di esempio per i cluster Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md)
+ [Installazione del carico di lavoro di esempio del proxy inverso NGINX per cluster Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-ecs.md)
+ [Esempio di carico di lavoro NGINX Plus per cluster Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md)
+ [Esercitazione per l'aggiunta di una nuova destinazione di scraping Prometheus: Memcached su Amazon ECS](ContainerInsights-Prometheus-Setup-memcached-ecs.md)
+ [Esercitazione per eseguire lo scraping delle metriche Prometheus di Redis OSS su Amazon ECS Fargate](ContainerInsights-Prometheus-Setup-redis-ecs.md)
# Carico di lavoro App Mesh di esempio per cluster Amazon ECS
Per raccogliere parametri da un carico di lavoro Prometheus di esempio per Amazon ECS, devi eseguire Container Insights nel cluster. Per informazioni sull'installazione di Container Insights, consulta [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md).
Per prima cosa, segui questa [spiegazione passo per passo](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs) per implementare l'app a colori di esempio sul cluster Amazon ECS. Dopo aver terminato, avrai i parametri di App Mesh Prometheus esposti sulla porta 9901.
Quindi, segui questi passaggi per installare l' CloudWatch agente con il monitoraggio Prometheus sullo stesso cluster Amazon ECS in cui hai installato l'app a colori. La procedura descritta in questa sezione consente di installare l' CloudWatch agente in modalità di rete bridge.
Le variabili di ambiente `ENVIRONMENT_NAME`, `AWS_PROFILE` e `AWS_DEFAULT_REGION` impostate nella spiegazione passo per passo verranno utilizzate anche nei passaggi seguenti.
**Per installare l' CloudWatch agente con Prometheus Monitoring for Testing**
1. Scarica il CloudFormation modello inserendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Imposta la modalità di rete immettendo i seguenti comandi.
```
export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME}
export ECS_NETWORK_MODE=bridge
```
1. Crea lo CloudFormation stack inserendo i seguenti comandi.
```
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=True \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=CWAgent-Prometheus-TaskRole-${ECS_CLUSTER_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=CWAgent-Prometheus-ExecutionRole-${ECS_CLUSTER_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
1. (Facoltativo) Quando viene creato lo CloudFormation stack, viene visualizzato un `CREATE_COMPLETE` messaggio. Per verificare lo stato prima di visualizzare il messaggio, inserisci il seguente comando.
```
aws cloudformation describe-stacks \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--query 'Stacks[0].StackStatus' \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Risoluzione dei problemi**
I passaggi della spiegazione passo per passo usano jq per analizzare il risultato di output della AWS CLI. Per ulteriori informazioni sull'installazione di jq, consulta [jq](https://stedolan.github.io/jq/). Usa il seguente comando per impostare il formato di output predefinito della tua AWS CLI su JSON in modo che jq possa analizzarlo correttamente.
```
$ aws configure
```
Quando la risposta arriva a `Default output format`, inserisci **json**.
## Disinstalla l' CloudWatch agente con il monitoraggio Prometheus
Al termine del test, immettete il seguente comando per disinstallare l' CloudWatchagente eliminando lo stack. CloudFormation
```
aws cloudformation delete-stack \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Java/JMX Carico di lavoro di esempio per i cluster Amazon ECS
JMX Exporter è un esportatore ufficiale di Prometheus che può recuperare ed esporre JMX mBeans JMX come metriche Prometheus. Per ulteriori informazioni, vedere [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
L' CloudWatch agente con supporto Prometheus analizza i parametri di Prometheus in Java/JMX base alla configurazione del service discovery nel cluster Amazon ECS. È possibile configurare JMX Exporter per esporre le metriche su una porta o metrics\$1path diverso. Se modifichi la porta o il percorso, aggiorna la sezione predefinita nella configurazione dell'agente. `ecs_service_discovery` CloudWatch
Per raccogliere parametri da un carico di lavoro Prometheus di esempio per Amazon ECS, devi eseguire Container Insights nel cluster. Per informazioni sull'installazione di Container Insights, consulta [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md).
**Per installare il carico di lavoro di Java/JMX esempio per i cluster Amazon ECS**
1. Procedi come descritto in queste sezioni per creare le immagini Docker.
+ [Esempio: immagine Docker dell'applicazione Java Jar con parametri Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar)
+ [Esempio: immagine Docker Apache Tomcat con parametri Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat)
1. Specifica le due etichette Docker seguenti nel file di definizione dell'attività Amazon ECS. Puoi quindi eseguire la definizione dell'attività come servizio Amazon ECS o attività Amazon ECS nel cluster.
+ Imposta `ECS_PROMETHEUS_EXPORTER_PORT` per puntare all'elemento containerPort in cui sono esposti i parametri Prometheus.
+ Imposta `Java_EMF_Metrics` su `true`. L' CloudWatch agente utilizza questo flag per generare il formato metrico incorporato nell'evento di registro.
Di seguito è riportato un esempio:
```
{
"family": "workload-java-ec2-bridge",
"taskRoleArn": "{{task-role-arn}}",
"executionRoleArn": "{{execution-role-arn}}",
"networkMode": "bridge",
"containerDefinitions": [
{
"name": "tomcat-prometheus-workload-java-ec2-bridge-dynamic-port",
"image": "your_docker_image_tag_for_tomcat_with_prometheus_metrics",
"portMappings": [
{
"hostPort": 0,
"protocol": "tcp",
"containerPort": 9404
}
],
"dockerLabels": {
"ECS_PROMETHEUS_EXPORTER_PORT": "9404",
"Java_EMF_Metrics": "true"
}
}
],
"requiresCompatibilities": [
"EC2" ],
"cpu": "256",
"memory": "512"
}
```
L'impostazione predefinita dell' CloudWatch agente nel CloudFormation modello consente sia l'individuazione dei servizi basata su etichette docker che l'individuazione dei servizi basata su ARN con definizione delle attività. Per visualizzare queste impostazioni predefinite, vedere la riga 65 del file di configurazione YAML dell'[ CloudWatch agente.](https://github.com/aws-samples/amazon-cloudwatch-container-insights/blob/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml#L65) I container con l'etichetta `ECS_PROMETHEUS_EXPORTER_PORT` verranno individuati automaticamente in base alla porta del container specificata per lo scraping di Prometheus.
L'impostazione predefinita dell' CloudWatch agente ha anche l'`metric_declaration`impostazione per Java/JMX la riga 112 dello stesso file. Tutte le etichette docker dei contenitori di destinazione verranno aggiunte come etichette aggiuntive nelle metriche di Prometheus e inviate a Logs. CloudWatch Per i Java/JMX contenitori con etichetta docker`Java_EMF_Metrics=“true”`, verrà generato il formato metrico incorporato.
# Installazione del carico di lavoro di esempio del proxy inverso NGINX per cluster Amazon ECS
L'esportatore NGINX Prometheus può sottoporre a scraping ed esporre i dati NGINX come parametri Prometheus. Questo esempio utilizza l'esportatore in tandem con il servizio proxy inverso NGINX per Amazon ECS.
Per ulteriori informazioni sull'esportatore NGINX Prometheus, vedi su Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Per ulteriori informazioni sul reverse proxy NGINX, vedi su Github. [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)
L' CloudWatch agente con supporto Prometheus analizza i parametri di NGINX Prometheus in base alla configurazione del service discovery nel cluster Amazon ECS. È possibile configurare NGINX dell'esportatore Prometheus per esporre i parametri su una porta o percorso diverso. Se modifichi la porta o il percorso, aggiorna la sezione nel file di configurazione dell'agente. `ecs_service_discovery` CloudWatch
## Installazione del carico di lavoro di esempio del proxy inverso NGINX per cluster Amazon ECS
Procedi come segue per installare il carico di lavoro di esempio del proxy inverso NGINX.
### Creazione delle immagini Docker
**Per creare le immagini Docker per il carico di lavoro di esempio del proxy inverso NGINX**
1. [Scarica la seguente cartella dal repository reverse proxy di NGINX: https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
1. Trova la directory `app` e crea un'immagine da quella directory:
```
docker build -t web-server-app ./path-to-app-directory
```
1. Crea un'immagine personalizzata per NGINX. Innanzitutto, crea una directory con i due file seguenti:
+ Un file Docker di esempio:
```
FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf
```
+ [Un `nginx.conf` file, modificato da/-proxy/: https://github.com/awslabs/ ecs-nginx-reverse-proxy tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
server{
listen 8080;
location /stub_status {
stub_status on;
}
}
server {
listen 80;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://app:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
**Nota**
`stub_status` deve essere abilitato nella stessa porta da cui `nginx-prometheus-exporter` è configurato per eseguire lo scraping dei parametri. Nella nostra definizione di attività di esempio, `nginx-prometheus-exporter` è configurato per eseguire lo scraping dei parametri dalla porta 8080.
1. Crea un'immagine dai file nella tua nuova directory:
```
docker build -t nginx-reverse-proxy ./path-to-your-directory
```
1. Carica le nuove immagini in un repository di immagini per utilizzarle in un secondo momento.
### Creazione della definizione dell'attività per eseguire NGINX e l'app del server Web in Amazon ECS
Successivamente, imposta la definizione dell'attività.
Questa definizione dell'attività consente la raccolta e l'esportazione deli parametri Prometheus NGINX. Il container NGINX tiene traccia dell'input dall'app ed espone tali dati alla porta 8080, come impostato in `nginx.conf`. Il contenitore NGINX prometheus exporter analizza queste metriche e le invia alla porta 9113, per utilizzarle in. CloudWatch
**Per impostare la definizione dell'attività per il carico di lavoro Amazon ECS di NGINX di esempio**
1. Crea un file JSON di definizione dell'attività con il seguente contenuto. *your-customized-nginx-iamge*Sostituiscila con l'URI dell'immagine per la tua immagine NGINX personalizzata e *your-web-server-app-image* sostituiscila con l'URI dell'immagine per l'immagine dell'app del server web.
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 256,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.scrape-uri",
"http://nginx:8080/stub_status"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-sample-stack"
}
```
1. Registra la definizione dell'attività inserendo il seguente comando.
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. Crea un servizio per eseguire l'attività inserendo il seguente comando:
Assicurati di non modificare il nome del servizio. Eseguiremo un servizio CloudWatch agente utilizzando una configurazione che cerca le attività utilizzando i modelli di nomi dei servizi che le hanno avviate. Ad esempio, per consentire all' CloudWatch agente di trovare l'attività avviata da questo comando, è possibile specificare il valore di `sd_service_name_pattern` to be`^nginx-service$`. La sezione successiva offre ulteriori dettagli.
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-service \
--task-definition nginx-sample-stack:1 \
--desired-count 1
```
### Configura l' CloudWatch agente per acquisire le metriche di NGINX Prometheus
Il passaggio finale consiste nel configurare l'agente per l'analisi delle metriche NGINX CloudWatch . In questo esempio, l' CloudWatch agente rileva l'attività tramite il modello del nome del servizio e la porta 9113, dove l'esportatore espone le metriche di Prometheus per NGINX. Una volta individuata l'attività e disponibili le metriche, l'agente inizia a pubblicare le metriche raccolte nel CloudWatch flusso di log. **nginx-prometheus-exporter**
**Per configurare l' CloudWatch agente per l'analisi delle metriche NGINX**
1. Scarica la versione più recente del file YAML necessario immettendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Apri il file con un editor di testo e trova la configurazione completa dell' CloudWatch agente nella chiave della sezione. `value` `resource:CWAgentConfigSSMParameter` Quindi, nella sezione `ecs_service_discovery` aggiungi la seguente sezione `service_name_list_for_tasks`.
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-service$"
}
],
```
1. Nello stesso file aggiungi la sezione seguente nella sezione `metric_declaration` per consentire i parametri NGINX. Assicurati di seguire il modello di rientro esistente.
```
{
"source_labels": ["job"],
"label_matcher": ".*nginx.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginx_.*$"
]
},
```
1. Se l' CloudWatch agente non è già distribuito in questo cluster, vai al passaggio 8.
Se hai già distribuito l' CloudWatch agente nel cluster Amazon ECS utilizzando AWS CloudFormation, puoi creare un set di modifiche inserendo i seguenti comandi:
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-scraping-support
```
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Rivedi il changeset appena creato. **nginx-scraping-support** Dovresti vedere una modifica applicata alla risorsa **CWAgentConfig. SSMParameter** Esegui il changeset e riavvia l'attività dell' CloudWatch agente inserendo il seguente comando:
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Se stai installando l' CloudWatch agente con la raccolta delle metriche di Prometheus sul cluster per la prima volta, inserisci i seguenti comandi.
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Visualizzazione dei parametri e dei log di NGINX
Ora puoi visualizzare i parametri NGINX raccolti.
**Per visualizzare i parametri per il carico di lavoro NGINX**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nella regione in cui è in esecuzione il cluster, scegli **Metrics** (Parametri) nel pannello di navigazione sinistro. Trova lo spazio dei nomi **ContainerInsights/Prometheus per visualizzare le** metriche.
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log **/aws/containerinsights/ /prometheus *your\$1cluster\$1name***, nel flusso di log. *nginx-prometheus-exporter*
# Esempio di carico di lavoro NGINX Plus per cluster Amazon ECS
NGINX Plus è la versione commerciale di NGINX. Per utilizzarla, è necessario disporre di una licenza. Per ulteriori informazioni, consulta [NGINX Plus](https://www.nginx.com/products/nginx/)
L'esportatore NGINX Prometheus può sottoporre a scraping ed esporre i dati NGINX come parametri Prometheus. Questo esempio utilizza l'esportatore in tandem con il servizio proxy inverso NGINX Plus per Amazon ECS.
Per ulteriori informazioni sull'esportatore NGINX Prometheus, vedi su Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Per ulteriori informazioni sul reverse proxy NGINX, vedi su Github. [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)
L' CloudWatch agente con supporto Prometheus analizza i parametri di NGINX Plus Prometheus in base alla configurazione del service discovery nel cluster Amazon ECS. È possibile configurare NGINX dell'esportatore Prometheus per esporre i parametri su una porta o percorso diverso. Se modifichi la porta o il percorso, aggiorna la sezione nel file di configurazione dell'agente. `ecs_service_discovery` CloudWatch
## Installazione del carico di lavoro di esempio del proxy inverso NGINX Plus per cluster Amazon ECS
Procedi come segue per installare il carico di lavoro di esempio del proxy inverso NGINX.
### Creazione delle immagini Docker
**Per creare le immagini Docker per il carico di lavoro di esempio del proxy inverso NGINX Plus**
1. [Scarica la seguente cartella dal repository reverse proxy di NGINX: https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
1. Trova la directory `app` e crea un'immagine da quella directory:
```
docker build -t web-server-app ./path-to-app-directory
```
1. Creazione di un'immagine personalizzata per NGINX Plus. Prima di poter creare l'immagine per NGINX Plus, è necessario ottenere la chiave denominata `nginx-repo.key` e il certificato SSL `nginx-repo.crt` per la tua licenza NGINX Plus. Crea una directory e archivia in essa i tuoi file `nginx-repo.key` e `nginx-repo.crt`.
Nella directory appena creata, crea i due file seguenti:
+ Un Dockerfile di esempio con il seguente contenuto. Questo file docker è adottato da un file di esempio fornito all'indirizzo [https://docs.nginx.com/nginx/admin- guide/installing-nginx/installing -nginx-docker/](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image) \$1docker\$1plus\$1image. La modifica importante che apportiamo è che carichiamo un file separato, chiamato `nginx.conf`, che verrà creato nel passaggio successivo.
```
FROM debian:buster-slim
LABEL maintainer="NGINX Docker Maintainers “
# Define NGINX versions for NGINX Plus and NGINX Plus modules
# Uncomment this block and the versioned nginxPackages block in the main RUN
# instruction to install a specific release
# ENV NGINX_VERSION 21
# ENV NJS_VERSION 0.3.9
# ENV PKG_RELEASE 1~buster
# Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/))
# and copy to the build context
COPY nginx-repo.crt /etc/ssl/nginx/
COPY nginx-repo.key /etc/ssl/nginx/
# COPY nginx.conf /etc/ssl/nginx/nginx.conf
RUN set -x \
# Create nginx user/group first, to be consistent throughout Docker variants
&& addgroup --system --gid 101 nginx \
&& adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \
&& \
NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \
found=''; \
for server in \
ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \
hkp://keyserver.ubuntu.com:80 \
hkp://p80.pool.sks-keyservers.net:80 \
pgp.mit.edu (http://pgp.mit.edu/) \
; do \
echo "Fetching GPG key $NGINX_GPGKEY from $server"; \
apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \
done; \
test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \
apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \
# Install the latest release of NGINX Plus and/or NGINX Plus modules
# Uncomment individual modules if necessary
# Use versioned packages over defaults to specify a release
&& nginxPackages=" \
nginx-plus \
# nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-xslt \
# nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-geoip \
# nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-image-filter \
# nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-perl \
# nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-njs \
# nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \
" \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \
&& printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
$nginxPackages \
gettext-base \
curl \
&& apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \
&& rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx
# Forward request logs to Docker log collector
RUN ln -sf /dev/stdout /var/log/nginx/access.log \
&& ln -sf /dev/stderr /var/log/nginx/error.log
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
STOPSIGNAL SIGTERM
CMD ["nginx", "-g", "daemon off;"]
```
+ [Un file, modificato da/. `nginx.conf` https://github.com/awslabs/ ecs-nginx-reverse-proxy tree/master/reverse-proxy/nginx](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx)
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
upstream backend {
zone name 10m;
server app:3000 weight=2;
server app2:3000 weight=1;
}
server{
listen 8080;
location /api {
api write=on;
}
}
match server_ok {
status 100-599;
}
server {
listen 80;
status_zone zone;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://backend;
health_check uri=/lorem-ipsum match=server_ok;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
1. Crea un'immagine dai file nella tua nuova directory:
```
docker build -t nginx-plus-reverse-proxy ./path-to-your-directory
```
1. Carica le nuove immagini in un repository di immagini per utilizzarle in un secondo momento.
### Creazione della definizione dell'attività per eseguire NGINX Plus e l'app del server Web in Amazon ECS
Successivamente, imposta la definizione dell'attività.
Questa definizione dell'attività consente la raccolta e l'esportazione deli parametri Prometheus NGINX Plus. Il container NGINX tiene traccia dell'input dall'app ed espone tali dati alla porta 8080, come impostato in `nginx.conf`. Il contenitore NGINX prometheus exporter analizza queste metriche e le invia alla porta 9113, per utilizzarle in. CloudWatch
**Per impostare la definizione dell'attività per il carico di lavoro Amazon ECS di NGINX di esempio**
1. Crea un file JSON di definizione dell'attività con il seguente contenuto. *your-customized-nginx-plus-image*Sostituiscila con l'URI dell'immagine per la tua immagine NGINX Plus personalizzata e *your-web-server-app-image* sostituiscila con l'URI dell'immagine per l'immagine dell'app del server web.
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-plus-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app",
"app2"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "app2",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.plus",
"-nginx.scrape-uri",
"http://nginx:8080/api"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-plus-sample-stack"
}
```
1. Registra la definizione dell'attività:
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. Crea un servizio per eseguire l'attività inserendo il seguente comando:
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-plus-service \
--task-definition nginx-plus-sample-stack:1 \
--desired-count 1
```
Assicurati di non modificare il nome del servizio. Eseguiremo un servizio CloudWatch agente utilizzando una configurazione che cerca le attività utilizzando i modelli di nomi dei servizi che le hanno avviate. Ad esempio, per consentire all' CloudWatch agente di trovare l'attività avviata da questo comando, è possibile specificare il valore di `sd_service_name_pattern` to be`^nginx-plus-service$`. La sezione successiva offre ulteriori dettagli.
### Configura l' CloudWatch agente per acquisire le metriche di NGINX Plus Prometheus
Il passaggio finale consiste nel configurare l'agente per l'analisi delle metriche NGINX CloudWatch . In questo esempio, l' CloudWatch agente rileva l'attività tramite il modello del nome del servizio e la porta 9113, dove l'esportatore espone le metriche di Prometheus per NGINX. Una volta individuata l'attività e disponibili le metriche, l'agente inizia a pubblicare le metriche raccolte nel CloudWatch flusso di log. **nginx-prometheus-exporter**
**Per configurare l' CloudWatch agente per l'analisi delle metriche NGINX**
1. Scarica la versione più recente del file YAML necessario immettendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Apri il file con un editor di testo e trova la configurazione completa dell' CloudWatch agente nella chiave della sezione. `value` `resource:CWAgentConfigSSMParameter` Quindi, nella sezione `ecs_service_discovery` aggiungi la seguente sezione `service_name_list_for_tasks`.
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-plus-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-plus.*"
}
],
```
1. Nello stesso file aggiungi la sezione seguente nella sezione `metric_declaration` per consentire i parametri NGINX Plus. Assicurati di seguire il modello di rientro esistente.
```
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginxplus_connections_accepted$",
"^nginxplus_connections_active$",
"^nginxplus_connections_dropped$",
"^nginxplus_connections_idle$",
"^nginxplus_http_requests_total$",
"^nginxplus_ssl_handshakes$",
"^nginxplus_ssl_handshakes_failed$",
"^nginxplus_up$",
"^nginxplus_upstream_server_health_checks_fails$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "upstream"]],
"metric_selectors": [
"^nginxplus_upstream_server_response_time$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "code"]],
"metric_selectors": [
"^nginxplus_upstream_server_responses$",
"^nginxplus_server_zone_responses$"
]
},
```
1. Se l' CloudWatch agente non è già distribuito in questo cluster, vai al passaggio 8.
Se hai già distribuito l' CloudWatch agente nel cluster Amazon ECS utilizzando AWS CloudFormation, puoi creare un set di modifiche inserendo i seguenti comandi:
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-plus-scraping-support
```
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Rivedi il changeset appena creato. **nginx-plus-scraping-support** Dovresti vedere una modifica applicata alla risorsa **CWAgentConfig. SSMParameter** Esegui il changeset e riavvia l'attività dell' CloudWatch agente inserendo il seguente comando:
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Se stai installando l' CloudWatch agente con la raccolta delle metriche di Prometheus sul cluster per la prima volta, inserisci i seguenti comandi.
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Visualizzazione deli parametri e dei log di NGINX Plus
Ora puoi visualizzare i parametri NGINX Plus raccolti.
**Per visualizzare i parametri per il carico di lavoro NGINX**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nella regione in cui è in esecuzione il cluster, scegli **Metrics** (Parametri) nel pannello di navigazione sinistro. Trova lo spazio dei nomi **ContainerInsights/Prometheus per visualizzare le** metriche.
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log **/aws/containerinsights/ /prometheus *your\$1cluster\$1name***, nel flusso di log. *nginx-plus-prometheus-exporter*
# Esercitazione per l'aggiunta di una nuova destinazione di scraping Prometheus: Memcached su Amazon ECS
Questa esercitazione offre un'introduzione pratica per eseguire lo scraping dei parametri Prometheus di un esempio di applicazione Memcached su un cluster Amazon ECS con il tipo di avvio EC2. Il target dell'esportatore Memcached Prometheus verrà scoperto automaticamente dall'agente mediante il rilevamento del servizio basato sulla definizione delle attività ECS. CloudWatch
Memcached è un sistema di caching in memoria implementato per scopo generico. Viene spesso utilizzato per accelerare i siti Web dinamici basati su database, memorizzando nella cache dati e oggetti nella RAM per ridurre il numero di volte in cui un'origine dati esterna (ad esempio un database o un'API) deve essere letta. Per ulteriori informazioni, consulta la pagina [Cos'è Memcached?](https://www.memcached.org/)
[memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (Apache License 2.0) è uno degli esportatori Prometheus ufficiali. Per impostazione predefinita, memcache\$1exporter serve sulla porta 0.0.0.0:9150 in `/metrics.`
In questa esercitazione vengono utilizzate le immagini Docker nei due repository Docker Hub seguenti:
+ [ Memcached](https://hub.docker.com/_/memcached?tab=description)
+ [ prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/)
**Prerequisito**
Per raccogliere parametri da un carico di lavoro Prometheus di esempio per Amazon ECS, devi eseguire Container Insights nel cluster. Per informazioni sull'installazione di Container Insights, consulta [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [Impostazione delle variabili di ambiente del cluster EC2 di Amazon ECS](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment)
+ [Installazione del carico di lavoro Memcached di esempio](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload)
+ [Configurare l' CloudWatch agente per acquisire le metriche di Memcached Prometheus](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent)
+ [Visualizzazione dei parametri Memcached](#ContainerInsights-Prometheus-ECS-memcached-view)
## Impostazione delle variabili di ambiente del cluster EC2 di Amazon ECS
**Per impostare le variabili di ambiente del cluster EC2 di Amazon ECS**
1. Installa la CLI di Amazon ECS, se non l'hai già fatto. Per ulteriori informazioni, consulta [Installazione della CLI di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).
1. Imposta il nuovo nome del cluster Amazon ECS e la nuova regione. Esempio:
```
ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Facoltativo) Se non disponi già di un cluster Amazon ECS con il tipo di avvio EC2 in cui desideri installare il carico di lavoro e l' CloudWatch agente Memcached di esempio, puoi crearne uno inserendo il seguente comando.
```
ecs-cli up --capability-iam --size 1 \
--instance-type t3.medium \
--cluster $ECS_CLUSTER_NAME \
--region $AWS_REGION
```
Il risultato previsto di questo comando è il seguente:
```
WARN[0000] You will not be able to SSH into your EC2 instances without a key pair.
INFO[0000] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.4 and Docker version 19.03.6-ce
INFO[0001] Created cluster cluster=ecs-ec2-memcached-tutorial region=ca-central-1
INFO[0002] Waiting for your cluster resources to be created...
INFO[0002] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0063] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0124] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Security Group created: sg-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Installazione del carico di lavoro Memcached di esempio
**Per installare il carico di lavoro Memcached di esempio che espone i parametri Prometheus**
1. Scarica il modello Memcached CloudFormation inserendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/memcached/memcached-traffic-sample.yaml
```
1. Imposta i nomi dei ruoli IAM da creare per Memcached inserendo i comandi riportati di seguito.
```
MEMCACHED_ECS_TASK_ROLE_NAME=memcached-prometheus-demo-ecs-task-role-name
MEMCACHED_ECS_EXECUTION_ROLE_NAME=memcached-prometheus-demo-ecs-execution-role-name
```
1. Installa il carico di lavoro Memcached di esempio inserendo il seguente comando. Questo esempio installa il carico di lavoro in modalità di rete `host`.
```
MEMCACHED_ECS_NETWORK_MODE=host
aws cloudformation create-stack --stack-name Memcached-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MODE \
--template-body file://memcached-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=ECSNetworkMode,ParameterValue=$MEMCACHED_ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$MEMCACHED_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$MEMCACHED_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
Lo CloudFormation stack crea quattro risorse:
+ Un ruolo dell'attività ECS
+ Un ruolo di esecuzione dell'attività ECS
+ Una definizione dell'attività Memcached
+ Un servizio di Memcached
Nella definizione dell'attività Memcached vengono definiti due container:
+ Il container primario esegue una semplice applicazione Memcached e apre la porta 11211 per l'accesso.
+ L'altro container esegue il processo dell'esportatore Redis OSS per esporre le metriche Prometheus sulla porta 9150. Questo è il contenitore che deve essere scoperto e raschiato dall' CloudWatch agente.
## Configurare l' CloudWatch agente per acquisire le metriche di Memcached Prometheus
**Per configurare l' CloudWatch agente per l'acquisizione delle metriche di Memcached Prometheus**
1. Scarica la versione più recente di `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` inserendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. Apri il file con un editor di testo e trova la configurazione completa dell' CloudWatch agente dietro la chiave nella sezione. `value` `resource:CWAgentConfigSSMParameter`
Quindi, nella sezione `ecs_service_discovery`, aggiungi la configurazione seguente nella sezione `task_definition_list`.
```
{
"sd_job_name": "ecs-memcached",
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+"
},
```
Per la sezione `metric_declaration`, l'impostazione predefinita non consente alcun parametro Memcached. Aggiungi la sezione seguente per consentire i parametri Memcached. Assicurati di seguire il modello di rientro esistente.
```
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily"]],
"metric_selectors": [
"^memcached_current_(bytes|items|connections)$",
"^memcached_items_(reclaimed|evicted)_total$",
"^memcached_(written|read)_bytes_total$",
"^memcached_limit_bytes$",
"^memcached_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily","status","command"], ["ClusterName", "TaskDefinitionFamily","command"]],
"metric_selectors": [
"^memcached_commands_total$"
]
},
```
1. Se hai già distribuito l' CloudWatch agente nel cluster Amazon ECS da CloudFormation, puoi creare un set di modifiche inserendo i seguenti comandi.
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name memcached-scraping-support
```
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Esamina il set di modifiche `memcached-scraping-support` appena creato. Dovresti vedere una modifica applicata alla risorsa `CWAgentConfigSSMParameter`. Esegui il changeset e riavvia l'attività dell' CloudWatch agente inserendo i seguenti comandi.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Se stai installando l' CloudWatch agente con la raccolta delle metriche Prometheus per il cluster per la prima volta, inserisci i seguenti comandi:
```
ECS_NETWORK_MODEE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Visualizzazione dei parametri Memcached
Questo tutorial invia le seguenti metriche al namespace in. **ECS/ContainerInsights/Prometheus** CloudWatch Puoi usare la CloudWatch console per vedere le metriche in quel namespace.
| Nome parametro | Dimensioni |
| --- | --- |
| `memcached_current_items` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_connections` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_limit_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_written_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_read_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_evicted_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_reclaimed_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_commands_total` | `ClusterName`, `TaskDefinitionFamily` `ClusterName`, comando TaskDefinitionFamily `ClusterName`, TaskDefinitionFamily, status, comando |
**Nota**
I valori della dimensione **command** (comando) possono essere: `delete`, `get`, `cas`, `set`, `decr`, `touch`, `incr` o `flush`.
I valori della dimensione **status** (stato) possono essere `hit`, `miss` o `badval`.
Puoi anche creare una CloudWatch dashboard per le metriche di Memcached Prometheus.
**Per creare un pannello di controllo per i parametri Prometheus di Memcached**
1. Crea variabili di ambiente, sostituendo i valori sotto in modo che corrispondano all'implementazione.
```
DASHBOARD_NAME=your_memcached_cw_dashboard_name
ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD
```
1. Inserisci il seguente comando per creare il pannello di controllo.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json \
| sed "s/{{YOUR_AWS_REGION}}/$AWS_REGION/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/$ECS_CLUSTER_NAME/g" \
| sed "s/{{YOUR_TASK_DEF_FAMILY}}/$ECS_TASK_DEF_FAMILY/g" \
| xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --region $AWS_REGION --dashboard-body
```
# Esercitazione per eseguire lo scraping delle metriche Prometheus di Redis OSS su Amazon ECS Fargate
Questa esercitazione offre un'introduzione pratica per recuperare le metriche Prometheus di un'applicazione Redis OSS di esempio in un cluster Amazon ECS Fargate. Il target dell'esportatore Redis OSS Prometheus verrà scoperto automaticamente dall' CloudWatch agente con il supporto metrico Prometheus basato sulle etichette docker del contenitore.
Redis OSS (https://redis.io/) è uno store di strutture dati open source (con licenza BSD), in memoria, utilizzato come database, cache e broker di messaggi. Per ulteriori informazioni, consulta la pagina [redis](https://redis.io/).
redis\$1exporter (con licenza MIT Licence) viene utilizzato per esporre le metriche Prometheus di Redis OSS sulla porta specificata (predefinita: 0.0.0.0:9121). Per ulteriori informazioni, consulta la pagina [redis\$1exporter](https://github.com/oliver006/redis_exporter).
In questa esercitazione vengono utilizzate le immagini Docker nei due repository Docker Hub seguenti:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Prerequisito**
Per raccogliere parametri da un carico di lavoro Prometheus di esempio per Amazon ECS, devi eseguire Container Insights nel cluster. Per informazioni sull'installazione di Container Insights, consulta [Configurazione di Container Insights su Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [Impostazione della variabile di ambiente del cluster Fargate di Amazon ECS](#ContainerInsights-Prometheus-Setup-redis-ecs-variable)
+ [Impostazione delle variabili di ambiente di rete per il cluster Fargate di Amazon ECS](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2)
+ [Installazione del carico di lavoro Redis OSS di esempio](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload)
+ [Configurare l' CloudWatch agente per l'acquisizione delle metriche Redis OSS Prometheus](#ContainerInsights-Prometheus-Setup-redis-ecs-agent)
+ [Visualizzazione delle metriche Redis OSS](#ContainerInsights-Prometheus-Setup-redis-view)
## Impostazione della variabile di ambiente del cluster Fargate di Amazon ECS
**Per impostare la variabile di ambiente del cluster Fargate di Amazon ECS**
1. Installa la CLI di Amazon ECS, se non l'hai già fatto. Per ulteriori informazioni, consulta [Installazione della CLI di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html).
1. Imposta il nuovo nome del cluster Amazon ECS e la nuova regione. Esempio:
```
ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Facoltativo) Se non disponi già di un cluster Amazon ECS Fargate in cui desideri installare il carico di lavoro CloudWatch e l'agente Redis OSS di esempio, puoi crearne uno inserendo il seguente comando.
```
ecs-cli up --capability-iam \
--cluster $ECS_CLUSTER_NAME \
--launch-type FARGATE \
--region $AWS_DEFAULT_REGION
```
Il risultato previsto di questo comando è il seguente:
```
INFO[0000] Created cluster cluster=ecs-fargate-redis-tutorial region=ca-central-1
INFO[0001] Waiting for your cluster resources to be created...
INFO[0001] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Impostazione delle variabili di ambiente di rete per il cluster Fargate di Amazon ECS
**Per impostare le variabili di ambiente di rete per il cluster Fargate di Amazon ECS**
1. Imposta il VPC e l'ID della sottorete del cluster Amazon ECS. Se hai stato creato un nuovo cluster nella procedura precedente, questi valori verranno visualizzati nel risultato del comando finale. Altrimenti, usa il cluster esistente che IDs intendi utilizzare con Redis.
```
ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx
```
1. In questo tutorial, installeremo l'applicazione Redis OSS e l' CloudWatch agente nel gruppo di sicurezza predefinito del VPC del cluster Amazon ECS. Il gruppo di sicurezza predefinito consente tutte le connessioni di rete all'interno dello stesso gruppo di sicurezza in modo che l' CloudWatch agente possa acquisire le metriche Prometheus esposte sui contenitori Redis OSS. In un ambiente di produzione reale, potresti voler creare gruppi di sicurezza dedicati per l'applicazione e l' CloudWatch agente Redis OSS e impostare autorizzazioni personalizzate per tali gruppi.
Per ottenere l'ID del gruppo di sicurezza predefinito, inserisci il comando seguente.
```
aws ec2 describe-security-groups \
--filters Name=vpc-id,Values=$ECS_CLUSTER_VPC \
--region $AWS_DEFAULT_REGION
```
Quindi imposta la variabile del gruppo di sicurezza predefinito del cluster Fargate inserendo il seguente comando, sostituendolo *my-default-security-group* con il valore trovato dal comando precedente.
```
ECS_CLUSTER_SECURITY_GROUP=my-default-security-group
```
## Installazione del carico di lavoro Redis OSS di esempio
**Per installare il carico di lavoro Redis OSS di esempio che espone le metriche Prometheus**
1. Scarica il CloudFormation modello Redis OSS inserendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml
```
1. Imposta i nomi dei ruoli IAM da creare per Redis OSS inserendo i comandi riportati di seguito.
```
REDIS_ECS_TASK_ROLE_NAME=redis-prometheus-demo-ecs-task-role-name
REDIS_ECS_EXECUTION_ROLE_NAME=redis-prometheus-demo-ecs-execution-role-name
```
1. Installa il carico di lavoro Redis OSS di esempio inserendo il seguente comando.
```
aws cloudformation create-stack --stack-name Redis-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-fargate-awsvpc \
--template-body file://redis-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET_1 \
ParameterKey=TaskRoleName,ParameterValue=$REDIS_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$REDIS_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_DEFAULT_REGION
```
Lo CloudFormation stack crea quattro risorse:
+ Un ruolo dell'attività ECS
+ Un ruolo di esecuzione dell'attività ECS
+ Una definizione dell'attività Redis OSS
+ Un servizio Redis OSS
Nella definizione dell'attività Redis OSS vengono definiti due container:
+ Il container primario esegue una semplice applicazione Redis OSS e apre la porta 6379 per l'accesso.
+ L'altro container esegue il processo dell'esportatore Redis OSS per esporre le metriche Prometheus sulla porta 9121. Questo è il contenitore che deve essere scoperto e raschiato dall' CloudWatch agente. La seguente etichetta docker è definita in modo che l' CloudWatch agente possa scoprire questo contenitore in base ad essa.
```
ECS_PROMETHEUS_EXPORTER_PORT: 9121
```
## Configurare l' CloudWatch agente per l'acquisizione delle metriche Redis OSS Prometheus
**Per configurare l' CloudWatch agente per l'acquisizione delle metriche Redis OSS Prometheus**
1. Scarica la versione più recente di `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` inserendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. Apri il file con un editor di testo e trova la configurazione completa dell' CloudWatch agente dietro la chiave nella sezione. `value` `resource:CWAgentConfigSSMParameter`
Poi, nella sezione `ecs_service_discovery` mostrata qui, il rilevamento servizi basato su `docker_label` è abilitato con le impostazioni predefinite che sono basate su `ECS_PROMETHEUS_EXPORTER_PORT`, che corrisponde all'etichetta Docker che abbiamo definito nella definizione dell'attività Redis OSS ECS. Quindi non abbiamo bisogno di apportare modifiche in questa sezione:
```
ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
* "docker_label": {
},*
...
```
Per la sezione `metric_declaration`, l'impostazione predefinita non consente alcuna metrica Redis OSS. Aggiungi la sezione seguente per consentire le metriche Redis OSS. Assicurati di seguire il modello di rientro esistente.
```
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
1. Se hai già distribuito l' CloudWatch agente nel cluster Amazon ECS da CloudFormation, puoi creare un set di modifiche inserendo i seguenti comandi.
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--change-set-name redis-scraping-support
```
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Esamina il set di modifiche `redis-scraping-support` appena creato. Dovresti vedere una modifica applicata alla risorsa `CWAgentConfigSSMParameter`. Esegui il changeset e riavvia l'attività dell' CloudWatch agente inserendo i seguenti comandi.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. Se stai installando l' CloudWatch agente con la raccolta delle metriche Prometheus per il cluster per la prima volta, inserisci i seguenti comandi:
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION}
```
## Visualizzazione delle metriche Redis OSS
Questo tutorial invia le seguenti metriche al namespace in. **ECS/ContainerInsights/Prometheus** CloudWatch Puoi usare la CloudWatch console per vedere le metriche in quel namespace.
| Nome parametro | Dimensioni |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_net_output_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_expired_keys_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_evicted_keys_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_keyspace_hits_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_keyspace_misses_total` | ClusterName, `TaskDefinitionFamily` |
| `redis_memory_used_bytes` | ClusterName, `TaskDefinitionFamily` |
| `redis_connected_clients` | ClusterName, `TaskDefinitionFamily` |
| `redis_commands_total` | ` ClusterName`, `TaskDefinitionFamily`, `cmd` |
| `redis_db_keys` | `ClusterName`, `TaskDefinitionFamily`, `db` |
**Nota**
Il valore della dimensione **cmd** può essere `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` o `slowlog`.
Il valore della dimensione **db** può essere da `db0` a `db15`.
Puoi anche creare una CloudWatch dashboard per le metriche di Redis OSS Prometheus.
**Per creare un pannello di controllo per le metriche Prometheus di Redis OSS**
1. Crea variabili di ambiente, sostituendo i valori sotto in modo che corrispondano all'implementazione.
```
DASHBOARD_NAME=your_cw_dashboard_name
ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
```
1. Inserisci il seguente comando per creare il pannello di controllo.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```
# Impostazione e configurazione della raccolta dei parametri Prometheus su cluster Amazon EKS e Kubernetes
Per raccogliere i parametri di Prometheus dai cluster che eseguono Amazon EKS o Kubernetes, puoi utilizzare l'agente come raccoglitore o utilizzare CloudWatch Distro for collector. AWS OpenTelemetry [Per informazioni sull'utilizzo di Distro for collector, consulta https://aws-otel.github. AWS OpenTelemetry io/docs/getting-started/container-insights/eks-prometeo.](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus)
Le sezioni seguenti spiegano come raccogliere le metriche di Prometheus utilizzando l'agente. CloudWatch Spiegano come installare l' CloudWatch agente con il monitoraggio Prometheus su cluster che eseguono Amazon EKS o Kubernetes e come configurare l'agente per acquisire obiettivi aggiuntivi. Offrono inoltre esercitazioni facoltative per l'impostazione di carichi di lavoro di esempio da utilizzare per i test con il monitoraggio Prometheus.
**Topics**
+ [Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Setup.md)
# Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes
Questa sezione spiega come configurare l' CloudWatch agente con il monitoraggio Prometheus in un cluster che esegue Amazon EKS o Kubernetes. Dopo aver eseguito questa operazione, l'agente esegue automaticamente lo scraping e l'importazione dei parametri per i seguenti carichi di lavoro in esecuzione in quel cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
È inoltre possibile configurare l'agente per recuperare e importare carichi di lavoro e origini Prometheus.
Prima di seguire questi passaggi per installare l' CloudWatch agente per la raccolta di metriche Prometheus, devi avere un cluster in esecuzione su Amazon EKS o un cluster Kubernetes in esecuzione su un'istanza Amazon EC2.
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
**Topics**
+ [Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes](#ContainerInsights-Prometheus-Setup-roles)
+ [Scraping di ulteriori origini Prometheus e importazione di tali parametri](ContainerInsights-Prometheus-Setup-configure.md)
+ [(Facoltativo) Impostazione dei carichi di lavoro Amazon EKS containerizzati di esempio per i test dei parametri di Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md)
## Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes
Questa sezione spiega come configurare l' CloudWatch agente con il monitoraggio Prometheus in un cluster che esegue Amazon EKS o Kubernetes. Dopo aver eseguito questa operazione, l'agente esegue automaticamente lo scraping e l'importazione dei parametri per i seguenti carichi di lavoro in esecuzione in quel cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
È inoltre possibile configurare l'agente per recuperare e importare carichi di lavoro e origini Prometheus.
Prima di seguire questi passaggi per installare l' CloudWatch agente per la raccolta di metriche Prometheus, devi avere un cluster in esecuzione su Amazon EKS o un cluster Kubernetes in esecuzione su un'istanza Amazon EC2.
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
**Topics**
+ [Impostazione dei ruoli IAM](#ContainerInsights-Prometheus-Setup-roles)
+ [Installazione dell' CloudWatch agente per raccogliere le metriche di Prometheus](#ContainerInsights-Prometheus-Setup-install-agent)
### Impostazione dei ruoli IAM
Il primo passo consiste nell'impostare il ruolo IAM necessario nel cluster. Esistono due metodi:
+ Impostare un ruolo IAM per un account di servizio, noto anche come *ruolo di servizio*. Questo metodo funziona sia per il tipo di avvio EC2 che per il tipo di avvio Fargate.
+ Aggiungere una policy IAM al ruolo IAM utilizzato per il cluster. Funziona solo per il tipo di avvio EC2.
**Impostazione di un ruolo di servizio (tipo di avvio EC2 e tipo di avvio Fargate)**
Per impostare un ruolo di servizio, immetti il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**Aggiungere una policy al ruolo IAM del nodo (solo tipo di avvio EC2)**
**Per impostare la policy IAM in un gruppo di nodi per il supporto di Prometheus**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.
1. È necessario trovare il prefisso del nome del ruolo IAM per il cluster. A tale scopo, seleziona la casella di controllo accanto al nome di un'istanza presente nel cluster e scegli **Azioni**, **Sicurezza**, **Modifica ruolo IAM**. Copia quindi il prefisso del ruolo IAM, ad esempio `eksctl-dev303-workshop-nodegroup`.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Utilizza la casella di ricerca per trovare il prefisso copiato in precedenza in questa procedura e scegli il ruolo desiderato.
1. Scegli **Collega policy**.
1. Usa la casella di ricerca per trovare **CloudWatchAgentServerPolicy**. Seleziona la casella di controllo accanto a **CloudWatchAgentServerPolicy**e scegli **Allega politica**.
### Installazione dell' CloudWatch agente per raccogliere le metriche di Prometheus
È necessario installare l' CloudWatch agente nel cluster per raccogliere le metriche. L'installazione dell'agente è diversa per cluster Amazon EKS e cluster Kubernetes.
**Eliminare le versioni precedenti dell' CloudWatch agente con il supporto Prometheus**
Se hai già installato una versione dell' CloudWatch agente con supporto Prometheus nel tuo cluster, devi eliminare quella versione immettendo il seguente comando. Questo è necessario solo per le versioni precedenti dell'agente con supporto di Prometheus. Non è necessario eliminare l' CloudWatch agente che abilita Container Insights senza il supporto di Prometheus.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### Installazione dell' CloudWatch agente su cluster Amazon EKS con il tipo di avvio EC2
Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS, segui questi passaggi.
**Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS**
1. Immetti il comando seguente per verificare se lo spazio dei nomi `amazon-cloudwatch` è già stato creato:
```
kubectl get namespace
```
1. Se `amazon-cloudwatch` non viene visualizzato nei risultati, crearlo immettendo il seguente comando:
```
kubectl create namespace amazon-cloudwatch
```
1. Per distribuire l'agente con la configurazione predefinita e fare in modo che invii i dati alla AWS regione in cui è installato, inserisci il seguente comando:
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per fare in modo che l'agente invii dati a un'area diversa, attenersi alla seguente procedura:
1. Scaricare il file YAML per l'agente immettendo il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
1. Apri il file con un editor di testo e cercare il blocco `cwagentconfig.json` del file.
1. Aggiungere le linee evidenziate, specificando l'area desiderata:
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. Salva il file e implementa l'agente utilizzando il file aggiornato.
```
kubectl apply -f prometheus-eks.yaml
```
#### Installazione dell' CloudWatch agente su cluster Amazon EKS con il tipo di avvio Fargate
Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS con il tipo di avvio Fargate, segui questi passaggi.
**Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS con il tipo di avvio Fargate**
1. Immettete il seguente comando per creare un profilo Fargate per l' CloudWatchagente in modo che possa essere eseguito all'interno del cluster. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. Per installare l' CloudWatch agente, immettere il seguente comando. Sostituisci *MyCluster* con il nome del cluster. Questo nome viene utilizzato nel nome del gruppo di log che memorizza gli eventi di log raccolti dall'agente e viene utilizzato anche come dimensione per le metriche raccolte dall'agente.
Sostituisci *region* con il nome della regione in cui desideri inviare le metriche. Ad esempio, `us-west-1`.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
#### Installazione dell' CloudWatch agente su un cluster Kubernetes
Per installare l' CloudWatch agente con supporto Prometheus su un cluster che esegue Kubernetes, inserisci il seguente comando:
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
Sostituisci *MyCluster* con il nome del cluster. Questo nome viene utilizzato nel nome del gruppo di log che memorizza gli eventi di log raccolti dall'agente e viene utilizzato anche come dimensione per le metriche raccolte dall'agente.
Sostituisci *region* con il nome della AWS regione in cui desideri inviare le metriche. Ad esempio, **us-west-1**.
#### Verifica dell'esecuzione dell'agente
In entrambi i cluster Amazon EKS e Kubernetes, puoi inserire il comando seguente per confermare che l'agente è in esecuzione.
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
Se i risultati includono un singolo pod di agenti `Running` nello stato, l' CloudWatch agente sta eseguendo e raccogliendo le metriche di Prometheus. Per impostazione predefinita, l' CloudWatchagente raccoglie le metriche per App Mesh, NGINX, Memcached, Java/JMX e ogni minuto. HAProxy Per ulteriori informazioni su questi parametri, consulta [Metriche di Prometheus raccolte dall'agente CloudWatch](ContainerInsights-Prometheus-metrics.md). Per istruzioni su come visualizzare le metriche di Prometheus in, consulta CloudWatch [Visualizzazione dei parametri Prometheus](ContainerInsights-Prometheus-viewmetrics.md)
Puoi anche configurare l' CloudWatch agente per raccogliere metriche da altri esportatori di Prometheus. Per ulteriori informazioni, consulta [Scraping di ulteriori origini Prometheus e importazione di tali parametri](ContainerInsights-Prometheus-Setup-configure.md).
# Scraping di ulteriori origini Prometheus e importazione di tali parametri
L' CloudWatch agente con monitoraggio Prometheus necessita di due configurazioni per analizzare le metriche di Prometheus. Una è per le configurazioni standard Prometheus come documentato in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) nella documentazione di Prometheus. L'altra è per la configurazione dell'agente. CloudWatch
Per i cluster Amazon EKS, le configurazioni sono definite in `prometheus-eks.yaml` (per il tipo di avvio EC2) o `prometheus-eks-fargate.yaml` (per il tipo di avvio Fargate) come due mappe di configurazione:
+ La sezione `name: prometheus-config` contiene le impostazioni per lo scraping di Prometheus.
+ La `name: prometheus-cwagentconfig` sezione contiene la configurazione per l' CloudWatch agente. Puoi utilizzare questa sezione per configurare la modalità di raccolta delle metriche di Prometheus da. CloudWatch Ad esempio, si specifica in quali metriche importare e si definiscono le relative dimensioni CloudWatch.
Per i cluster Kubernetes in esecuzione su istanze Amazon EC2, le configurazioni sono definite nel file YAML `prometheus-k8s.yaml` come due mappe di configurazione:
+ La sezione `name: prometheus-config` contiene le impostazioni per lo scraping di Prometheus.
+ La `name: prometheus-cwagentconfig` sezione contiene la configurazione per l' CloudWatch agente.
Per acquisire ulteriori fonti di metriche Prometheus e importare tali metriche in, è necessario modificare sia la configurazione dello scrape di Prometheus che la configurazione dell'agente, quindi ridistribuire l'agente con la configurazione aggiornata. CloudWatch CloudWatch
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
## Configurazione di Prometheus Scrape
L' CloudWatch agente supporta le configurazioni scrape standard di Prometheus come documentato nella documentazione di Prometheus.[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) È possibile modificare questa sezione per aggiornare le configurazioni già presenti in questo file e aggiungere ulteriori destinazioni di scraping Prometheus. Per impostazione predefinita, il file di configurazione campione contiene le seguenti righe di configurazione globali:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval**: definisce con quale frequenza recuperare le destinazioni.
+ **scrape\$1timeout**: definisce quanto tempo attendere prima che una richiesta di scrape scada.
È inoltre possibile definire valori diversi per queste impostazioni a livello di processo, per ignorare le configurazioni globali.
### Attività di scraping di Prometheus
Nei file YAML dell' CloudWatch agente sono già configurati alcuni processi di scraping predefiniti. Ad esempio, in `prometheus-eks.yaml`, i processi di scraping predefiniti sono configurati nelle righe `job_name` nella sezione `scrape_configs`. In questo file, la sezione `kubernetes-pod-jmx` predefinita seguente recupera i parametri di JMX Exporter.
```
- job_name: 'kubernetes-pod-jmx'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: labelmap
regex: __meta_kubernetes_pod_label_(.+)
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- source_labels: [__meta_kubernetes_pod_name]
action: replace
target_label: pod_name
- action: replace
source_labels:
- __meta_kubernetes_pod_container_name
target_label: container_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_name
target_label: pod_controller_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_kind
target_label: pod_controller_kind
- action: replace
source_labels:
- __meta_kubernetes_pod_phase
target_label: pod_phase
```
Ciascuno di questi obiettivi predefiniti viene eliminato e le metriche vengono inviate agli eventi di registro utilizzando il formato CloudWatch metrico incorporato. Per ulteriori informazioni, consulta [Incorporamento dei parametri nei log](CloudWatch_Embedded_Metric_Format.md).
Gli eventi di log dei cluster Amazon EKS e Kubernetes vengono archiviati nel gruppo di log **/aws/containerinsights/ /prometheus *cluster\$1name*** in Logs. CloudWatch Gli eventi di log dei cluster Amazon ECS vengono archiviati nel gruppo di log**/aws/ecs/containerinsights/*cluster\$1name*/prometheus.**
Ogni processo di scraping è contenuto in un flusso di log diverso in questo gruppo di log. Ad esempio, il processo di scraping Prometheus `kubernetes-pod-appmesh-envoy` è definito per App Mesh. **Tutte le metriche App Mesh Prometheus dei cluster Amazon EKS e Kubernetes vengono inviate al flusso di log denominato /aws/containerinsights/ >prometheus//. *cluster\$1name* kubernetes-pod-appmesh-envoy**
Per aggiungere una nuova destinazione di scraping, aggiungere una nuova sezione `job_name` alla sezione `scrape_configs` del file YAML e riavviare l'agente. Per un esempio di questo processo, vedere [Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus](#ContainerInsights-Prometheus-Setup-new-exporters).
## CloudWatch configurazione dell'agente per Prometheus
Il file di configurazione CloudWatch dell'agente ha una `prometheus` sezione sotto `metrics_collected` per la configurazione dello scraping di Prometheus. Include le opzioni di configurazione seguenti:
+ **cluster\$1name**: specifica il nome del cluster da aggiungere come etichetta nell'evento log. Questo campo è facoltativo. Se li ometti, l'agente può rilevare il nome del cluster Amazon EKS o Kubernetes.
+ **log\$1group\$1name**: specifica il nome del gruppo di log per i parametri Prometheus sottoposti a scraping. Questo campo è facoltativo. Se lo CloudWatch ometti, utilizza **/aws/containerinsights/ *cluster\$1name* /prometheus** per i log dei cluster Amazon EKS e Kubernetes.
+ **prometheus\$1config\$1path**: specifica il percorso del file di configurazione di scraping di Prometheus. Se il valore di questo campo inizia con `env:`, il contenuto del file di configurazione di scraping di Prometheus verrà recuperato dalla variabile di ambiente del container. Non modificare questo campo.
+ **ecs\$1service\$1discovery**: è la sezione per specificare la configurazione per l'individuazione del servizio Amazon ECS Prometheus. Per ulteriori informazioni, consulta la pagina [Guida dettagliata per l'individuazione automatica dei cluster Amazon ECS](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md).
La sezione `ecs_service_discovery` può contenere i seguenti campi:
+ `sd_frequency` è la frequenza di individuazione degli elementi di esportazione di Prometheus. Specifica un numero e un suffisso di unità. Ad esempio, `1m` per una volta al minuto o `30s` per una volta ogni 30 secondi. I suffissi di unità validi sono `ns`, `us`, `ms`, `s`, `m` e `h`.
Questo campo è facoltativo. Il valore predefinito è 60 secondi (1 minuto).
+ `sd_target_cluster` è il nome del cluster Amazon ECS di destinazione per l'individuazione automatica. Questo campo è facoltativo. L'impostazione predefinita è il nome del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_cluster_region` è la regione del cluster Amazon ECS di destinazione. Questo campo è facoltativo. L'impostazione predefinita è la regione del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_result_file` è il percorso del file YAML per i risultati di destinazione di Prometheus. La configurazione di scraping di Prometheus farà riferimento a questo file.
+ `docker_label` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati su etichette Docker. Se ometti questa sezione, l'individuazione basata sull'etichetta Docker non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_port_label` è il nome dell'etichetta Docker del container che specifica la porta del container per i parametri Prometheus. Il valore predefinito è `ECS_PROMETHEUS_EXPORTER_PORT`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente la salterà.
+ `sd_metrics_path_label` è il nome dell'etichetta Docker del container che specifica il percorso dei parametri di Prometheus. Il valore predefinito è `ECS_PROMETHEUS_METRICS_PATH`. Se il container non dispone di questa etichetta Docker, l'agente assume il percorso predefinito `/metrics`.
+ `sd_job_name_label` è il nome dell'etichetta Docker del container che specifica il nome del processo di scraping di Prometheus. Il valore predefinito è `job`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ `task_definition_list` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati sulla definizione dell'attività. Se ometti questa sezione, l'individuazione basata sulla definizione dell'attività non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_task_definition_arn_pattern` è il modello da utilizzare per specificare le definizioni delle attività Amazon ECS da individuare. Questa è un'espressione regolare.
+ `sd_metrics_ports` elenca gli elementi containerPort per i parametri di Prometheus. Separa gli elementi containerPort con il punto e virgola.
+ `sd_container_name_pattern` specifica i nomi dei container dell'attività di Amazon ECS. Questa è un'espressione regolare.
+ `sd_metrics_path` specifica il percorso del parametro Prometheus. Se ometti questa opzione, l'agente assume il percorso predefinito `/metrics`
+ `sd_job_name` specifica il nome del processo di scraping di Prometheus. Se si omette questo campo, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ **metric\$1declaration**: sono sezioni che specificano la matrice di log con formato metrico incorporato da generare. Esistono `metric_declaration` sezioni per ogni sorgente Prometheus da cui l'agente importa per impostazione predefinita CloudWatch . Ciascuna di queste sezioni include i seguenti campi:
+ `label_matcher` è un'espressione regolare che controlla il valore delle etichette elencate in `source_labels`. Le metriche corrispondenti sono abilitate per l'inclusione nel formato metrico incorporato inviato a. CloudWatch
Se sono state specificate più etichette in `source_labels`, ti consigliamo di non utilizzare `^` o caratteri `$` nell'espressione regolare per `label_matcher`.
+ `source_labels` specifica il valore delle etichette controllate dalla riga `label_matcher`.
+ `label_separator` specifica il separatore da utilizzare nella riga ` label_matcher` se sono specificati `source_labels` multipli. Il valore predefinito è `;`. È possibile visualizzare questo valore predefinito utilizzato nella riga `label_matcher` nell'esempio seguente.
+ `metric_selectors` è un'espressione regolare che specifica le metriche da raccogliere e inviare a CloudWatch.
+ `dimensions` è l'elenco delle etichette da utilizzare come dimensioni CloudWatch per ogni metrica selezionata.
Guarda l'esempio `metric_declaration` che segue.
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
In questo esempio viene configurata una sezione di formato metrica incorporata da inviare come evento di log se sono soddisfatte le seguenti condizioni:
+ Il valore di `Service` contiene `node-exporter` o `kube-dns`.
+ Il valore di `Namespace` è `kube-system`.
+ La metrica Prometheus `coredns_dns_request_type_count_total` contiene le etichette sia `Service` che `Namespace`.
L'evento di log inviato include la seguente sezione evidenziata:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
## Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus
Kubernetes API Server espone le metriche Prometheus sugli endpoint per impostazione predefinita. L'esempio ufficiale per la configurazione di scraping Kubernetes API Server è disponibile su [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml).
La seguente esercitazione mostra come eseguire le seguenti operazioni per iniziare a importare le metriche di Kubernetes API Server in CloudWatch:
+ Aggiungere la configurazione di scraping Prometheus per Kubernetes API Server al file YAML dell'agente. CloudWatch
+ Configurazione delle definizioni delle metriche in formato metrico incorporato nel file YAML dell'agente. CloudWatch
+ (Facoltativo) Creazione di una CloudWatch dashboard per le metriche del Kubernetes API Server.
**Nota**
Kubernetes API Server espone le metriche misuratore, contatore, istogramma e riepilogo. In questa versione del supporto alle metriche di Prometheus CloudWatch , importa solo le metriche con i tipi gauge, counter e summary.
**Per iniziare a raccogliere le metriche di Kubernetes API Server Prometheus in CloudWatch**
1. Scaricare la versione più recente del file `prometheus-eks.yaml`, `prometheus-eks-fargate.yaml` o `prometheus-k8s.yaml` immettendo uno dei seguenti comandi.
Per un cluster Amazon EKS con tipo di avvio EC2, immetti il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, immetti il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Per un cluster Kubernetes in esecuzione su un'istanza Amazon EC2, inserisci il comando seguente:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. Apri il file con un editor di testo, trova la sezione `prometheus-config` e aggiungi la sezione seguente all'interno di tale sezione. Salvare quindi le modifiche:
```
# Scrape config for API servers
- job_name: 'kubernetes-apiservers'
kubernetes_sd_configs:
- role: endpoints
namespaces:
names:
- default
scheme: https
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
relabel_configs:
- source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
action: keep
regex: kubernetes;https
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- action: replace
source_labels:
- __meta_kubernetes_service_name
target_label: Service
```
1. Mentre hai ancora il file YAML aperto nell'editor di testo, trova la sezione `cwagentconfig.json`. Aggiungi la seguente sottosezione e salva le modifiche. Questa sezione inserisce le metriche del server API nell'elenco degli agenti consentiti. CloudWatch All'elenco degli agenti consentiti vengono aggiunti tre tipi di parametri del server API:
+ Conteggi di oggetti etcd
+ Metriche del controller di registrazione del server API
+ Metriche delle richieste del server API
```
{"source_labels": ["job", "resource"],
"label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
"dimensions": [["ClusterName","Service","resource"]],
"metric_selectors": [
"^etcd_object_counts$"
]
},
{"source_labels": ["job", "name"],
"label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
"dimensions": [["ClusterName","Service","name"]],
"metric_selectors": [
"^workqueue_depth$",
"^workqueue_adds_total$",
"^workqueue_retries_total$"
]
},
{"source_labels": ["job","code"],
"label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
"dimensions": [["ClusterName","Service","code"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
{"source_labels": ["job"],
"label_matcher": "^kubernetes-apiservers",
"dimensions": [["ClusterName","Service"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
```
1. Se l' CloudWatch agente con supporto Prometheus è già distribuito nel cluster, devi eliminarlo inserendo il seguente comando:
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Distribuisci l' CloudWatch agente con la configurazione aggiornata immettendo uno dei seguenti comandi. Per un cluster Amazon EKS con tipo di avvio EC2, inserisci:
```
kubectl apply -f prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, immetti il seguente comando. Sostituisci *MyCluster* e *region* con i valori corrispondenti alla tua distribuzione.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Per un cluster Kubernetes, immetti il seguente comando. Sostituisci *MyCluster* e *region* con valori adatti alla tua implementazione.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
**Dopo averlo fatto, dovresti vedere un nuovo flusso di log chiamato **kubernetes-apiservers nel gruppo di log /aws/containerinsights/** /prometheus. *cluster\$1name*** Questo flusso di log deve includere eventi log con una definizione del formato del parametro incorporata come la seguente:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"apiserver_request_total"
}
],
"Dimensions":[
[
"ClusterName",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"ClusterName":"my-cluster-name",
"Namespace":"default",
"Service":"kubernetes",
"Timestamp":"1592267020339",
"Version":"0",
"apiserver_request_count":0,
"apiserver_request_total":0,
"code":"0",
"component":"apiserver",
"contentType":"application/json",
"instance":"192.0.2.0:443",
"job":"kubernetes-apiservers",
"prom_metric_type":"counter",
"resource":"pods",
"scope":"namespace",
"verb":"WATCH",
"version":"v1"
}
```
Puoi visualizzare le tue metriche nella CloudWatch console nel namespace **ContainerInsights/Prometheus.** Facoltativamente, puoi anche creare una CloudWatch dashboard per le metriche del server API Prometheus Kubernetes.
### (Facoltativo) Creazione di un pannello di controllo per i parametri del server API di Kubernetes
Per visualizzare le metriche del server API Kubernetes nel dashboard, è necessario prima aver completato i passaggi nelle sezioni precedenti per iniziare a raccogliere queste metriche in CloudWatch.
**Per creare un pannello di controllo per i parametri del server API Kubernetes**
1. CloudWatch Apri [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)la console all'indirizzo.
1. Assicurati di aver selezionato la AWS regione corretta.
1. Nel pannello di navigazione seleziona **Dashboards** (Pannelli di controllo).
1. Scegli **Crea pannello di controllo)**. Immetti un nome per il nuovo dashboard e scegli **Crea dashboard**.
1. In **Add to this dashboard** (Aggiungi a questo pannello di controllo), scegli **Cancel** (Annulla).
1. Seleziona **Actions (Operazioni)**, **View/edit source (Visualizza/modifica origine)**.
1. Scaricare il seguente file JSON: [origine del pannello di controllo API Kubernetes](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json).
1. Apri il file JSON scaricato con un editor di testo e apporta le seguenti modifiche:
+ Sostituire tutte le stringhe `{{YOUR_CLUSTER_NAME}}` con il nome esatto del cluster. Assicurarti di non aggiungere spazi bianchi prima o dopo il testo.
+ Sostituisci tutte le stringhe `{{YOUR_AWS_REGION}}` con il nome della regione in cui vengono raccolti i parametri. Ad esempio, `us-west-2`. Assicurarti di non aggiungere spazi bianchi prima o dopo il testo.
1. Copiare l'intero BLOB JSON e incollarlo nella casella di testo nella console CloudWatch, sostituendo ciò che è già presente nella casella.
1. Scegli **Update** (Aggiorna), **Save dashboard** (Salva pannello di controllo).
# (Facoltativo) Impostazione dei carichi di lavoro Amazon EKS containerizzati di esempio per i test dei parametri di Prometheus
Per testare il supporto delle metriche Prometheus CloudWatch in Container Insights, puoi configurare uno o più dei seguenti carichi di lavoro containerizzati. L' CloudWatch agente con supporto Prometheus raccoglie automaticamente le metriche da ciascuno di questi carichi di lavoro. Per visualizzare le metriche raccolte per impostazione predefinita, vedere [Metriche di Prometheus raccolte dall'agente CloudWatch](ContainerInsights-Prometheus-metrics.md).
Prima di installare uno qualsiasi di questi carichi di lavoro, è necessario installare Helm 3.x immettendo i seguenti comandi:
```
brew install helm
```
Per ulteriori informazioni, consulta la pagina [Helm](https://helm.sh).
**Topics**
+ [Configura un carico AWS App Mesh di lavoro di esempio per Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [Configurazione di NGINX con traffico di esempio su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [Impostazione di memcached con un esportatore di parametri su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Configura un carico Java/JMX di lavoro di esempio su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [Configura HAProxy con un esportatore di metriche su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Esercitazione per l'aggiunta di una nuova destinazione di scraping di Prometheus: Redis OSS su Amazon EKS e cluster Kubernetes](ContainerInsights-Prometheus-Setup-redis-eks.md)
# Configura un carico AWS App Mesh di lavoro di esempio per Amazon EKS e Kubernetes
Il supporto di Prometheus nei supporti di Container Insights. CloudWatch AWS App Mesh Nelle sezioni seguenti viene illustrato come configurare App Mesh.
**Topics**
+ [Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di lancio Fargate](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes
Segui queste istruzioni se stai configurando App Mesh su un cluster che esegue Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes.
## Configurazione delle autorizzazioni IAM
Devi aggiungere la **AWSAppMeshFullAccess**policy al ruolo IAM per il tuo gruppo di nodi Amazon EKS o Kubernetes. Su Amazon EKS, il nome del gruppo di nodi è simile a `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL`. Su Kubernetes, potrebbe sembrare simile a `nodes.integ-test-kops-prometheus.k8s.local`.
## Installazione di App Mesh
Per installare il controller App Mesh Kubernetes, segui le istruzioni in [Controller di App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller).
## Installazione di un'applicazione di esempio
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contiene diverse procedure dettagliate per Kubernetes App Mesh. Per questa esercitazione, installerai un'applicazione a colori di esempio che mostra come i routing http possono utilizzare le intestazioni per la corrispondenza delle richieste in arrivo.
**Per utilizzare un'applicazione App Mesh di esempio per testare Container Insights**
1. Installa l'applicazione seguendo queste istruzioni: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers).
1. Avvia un pod curler per generare traffico:
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. Esegui il curl diversi endpoint modificando le intestazioni HTTP. Esegui il comando curl più volte, come illustrato:
```
curl -H "color_header: blue" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: red" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: yellow" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
```
1. CloudWatch Apri la console [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)all'indirizzo.
1. Nella AWS regione in cui è in esecuzione il cluster, scegli **Metriche** nel riquadro di navigazione. La metrica si trova nello spazio dei nomi **ContainerInsights/Prometheus.**
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log ` /aws/containerinsights/your_cluster_name/prometheus ` nel flusso di log `kubernetes-pod-appmesh-envoy`.
## Eliminazione dell'ambiente di test di App Mesh
Al termine dell'utilizzo di App Mesh e dell'applicazione di esempio, utilizza i seguenti comandi per eliminare le risorse non necessarie. Elimina l'applicazione di esempio immettendo il seguente comando:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
Elimina il controller App Mesh immettendo il seguente comando:
```
helm delete appmesh-controller -n appmesh-system
```
# Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di lancio Fargate
Segui queste istruzioni se stai configurando App Mesh su un cluster che esegue Amazon EKS con il tipo di avvio Fargate.
## Configurazione delle autorizzazioni IAM
Per impostare le autorizzazioni IAM, immetti il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
## Installazione di App Mesh
Per installare il controller App Mesh Kubernetes, segui le istruzioni in [Controller di App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller). Assicurati di seguire le istruzioni per Amazon EKS con il tipo di avvio Fargate.
## Installazione di un'applicazione di esempio
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contiene diverse procedure dettagliate per Kubernetes App Mesh. Per questa esercitazione, installerai un'applicazione a colori di esempio che funziona per i cluster Amazon EKS con il tipo di avvio Fargate.
**Per utilizzare un'applicazione App Mesh di esempio per testare Container Insights**
1. Installa l'applicazione seguendo queste istruzioni: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate).
Queste istruzioni presuppongono che tu stia creando un nuovo cluster con il profilo Fargate corretto. Se si desidera utilizzare un cluster Amazon EKS già configurato, puoi utilizzare i seguenti comandi per configurare tale cluster per questa dimostrazione. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
```
eksctl create fargateprofile --cluster MyCluster \
--namespace howto-k8s-fargate --name howto-k8s-fargate
```
1. Esegui il port forwarding dell'implementazione dell'applicazione front:
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. Esegui il curl dell'App front:
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. CloudWatch Apri la console [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)all'indirizzo.
1. Nella AWS regione in cui è in esecuzione il cluster, scegli **Metriche** nel riquadro di navigazione. La metrica si trova nello spazio dei nomi **ContainerInsights/Prometheus.**
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log ` /aws/containerinsights/your_cluster_name/prometheus ` nel flusso di log `kubernetes-pod-appmesh-envoy`.
## Eliminazione dell'ambiente di test di App Mesh
Al termine dell'utilizzo di App Mesh e dell'applicazione di esempio, utilizza i seguenti comandi per eliminare le risorse non necessarie. Elimina l'applicazione di esempio immettendo il seguente comando:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
Elimina il controller App Mesh immettendo il seguente comando:
```
helm delete appmesh-controller -n appmesh-system
```
# Configurazione di NGINX con traffico di esempio su Amazon EKS e Kubernetes
NGINX è un server web che può essere utilizzato anche come load balancer e proxy inverso. Per ulteriori informazioni sul modo in cui Kubernetes utilizza NGINX per ingresso, consulta [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx).
**Per installare Ingress-NGINX con un servizio di traffico di esempio per testare il supporto di Container Insights Prometheus**
1. Immetti il seguente comando per aggiungere il repository Helm ingress-nginx:
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. Eseguire i comandi seguenti:
```
kubectl create namespace nginx-ingress-sample
helm install my-nginx ingress-nginx/ingress-nginx \
--namespace nginx-ingress-sample \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="10254" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Verificare se i servizi sono stati avviati correttamente immettendo il seguente comando:
```
kubectl get service -n nginx-ingress-sample
```
L'output di questo comando dovrebbe visualizzare diverse colonne, inclusa una colonna `EXTERNAL-IP`.
1. Impostare una variabile `EXTERNAL-IP` sul valore della colonna `EXTERNAL-IP` nella riga del controller di ingresso NGINX.
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. Avviare un esempio di traffico NGINX inserendo il seguente comando.
```
SAMPLE_TRAFFIC_NAMESPACE=nginx-sample-traffic
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/nginx-traffic/nginx-traffic-sample.yaml |
sed "s/{{external_ip}}/$EXTERNAL_IP/g" |
sed "s/{{namespace}}/$SAMPLE_TRAFFIC_NAMESPACE/g" |
kubectl apply -f -
```
1. Immetti il comando seguente per verificare che tutti e tre i pod siano nello stato `Running`.
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
Se sono in esecuzione, dovresti presto vedere le metriche nello spazio dei nomi **ContainerInsights/Prometheus.**
**Per disinstallare NGINX e l'applicazione di traffico di esempio**
1. Eliminare il servizio traffico di esempio immettendo il seguente comando:
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Elimina l'uscita NGINX in base al nome della versione di Helm.
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# Impostazione di memcached con un esportatore di parametri su Amazon EKS e Kubernetes
memcached è un sistema di memorizzazione nella cache di oggetti di memoria open source. Per ulteriori informazioni, consulta la pagina [Cos'è Memcached?](https://www.memcached.org).
Se esegui memcached in un cluster con il tipo di avvio Fargate, devi impostare un profilo Fargate prima di eseguire la procedura descritta. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**Per installare memcached con un esportatore di metriche per testare il supporto di Container Insights Prometheus**
1. Inserisci il seguente comando per aggiungere il repository:
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. Immetti il seguente comando per creare un nuovo spazio di nomi:
```
kubectl create namespace memcached-sample
```
1. Immetti il seguente comando per installare Memcached
```
helm install my-memcached bitnami/memcached --namespace memcached-sample \
--set metrics.enabled=true \
--set-string serviceAnnotations.prometheus\\.io/port="9150" \
--set-string serviceAnnotations.prometheus\\.io/scrape="true"
```
1. Immetti il comando seguente per confermare l'annotazione del servizio in esecuzione:
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
Dovresti vedere le due annotazioni seguenti:
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**Per disinstallare memcached**
+ Eseguire i comandi seguenti:
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Configura un carico Java/JMX di lavoro di esempio su Amazon EKS e Kubernetes
JMX Exporter è un esportatore ufficiale di Prometheus che può recuperare ed esporre JMX mBeans JMX come metriche Prometheus. Per ulteriori informazioni, vedere [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
Container Insights può raccogliere metriche Prometheus predefinite da Java Virtual Machine (JVM), Java e Tomcat (Catalina) utilizzando JMX Exporter.
## Configurazione predefinita dello scraping di Prometheus
Per impostazione predefinita, l' CloudWatch agente con supporto Prometheus analizza i parametri Java/JMX Prometheus da ogni pod in un cluster Amazon EKS o Kubernetes. `http://CLUSTER_IP:9404/metrics` Questo avviene mediante l'individuazione di `role: pod` di `kubernetes_sd_config` Prometheus. 9404 è la porta predefinita allocata per JMX Exporter da Prometheus. Per ulteriori informazioni sull'individuazione di `role: pod`, consulta [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). È possibile configurare JMX Exporter per esporre le metriche su una porta o metrics\$1path diverso. Se modifichi la porta o il percorso, aggiorna il jmx scrape\$1config predefinito nella mappa di configurazione dell'agente. CloudWatch Esegui il seguente comando per ottenere la configurazione corrente dell' CloudWatch agente Prometheus:
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
I campi da modificare sono i campi `/metrics` e `regex: '.*:9404$'`, come evidenziato nell'esempio seguente.
```
job_name: 'kubernetes-jmx-pod'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: replace
regex: (.+)
source_labels:
```
## Altra configurazione di scraping di Prometheus
Se esponi la tua applicazione in esecuzione su un set di pod con esportatori Java/JMX Prometheus da un servizio Kubernetes, puoi anche passare all'uso dell'individuazione di `role: service` o all'individuazione di `role: endpoint` di `kubernetes_sd_config` Prometheus. Per ulteriori informazioni su questi metodi di individuazione, consulta [service](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service) (servizio), [ endpoints](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints) (endpoint) e [ .](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
Queste due modalità di individuazione dei servizi forniscono altre meta etichette che potrebbero essere utili per creare le dimensioni delle CloudWatch metriche. Ad esempio, puoi rietichettare `__meta_kubernetes_service_name` con `Service` e includerlo nella dimensione dei tuoi parametri. Per ulteriori informazioni sulla personalizzazione delle CloudWatch metriche e delle relative dimensioni, consulta. [CloudWatch configurazione dell'agente per Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)
## Immagine Docker con JMX Exporter
Successivamente, crea un'immagine Docker. Le sezioni seguenti forniscono due file Docker di esempio.
Dopo aver creato l'immagine, caricarla in Amazon EKS o Kubernetes, quindi eseguire il comando seguente per verificare che i parametri Prometheus siano esposte da `JMX_EXPORTER` sulla porta 9404. *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD*Sostituiscilo con il nome del pod in esecuzione e sostituiscilo *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* con lo spazio dei nomi dell'applicazione.
Se esegui JMX Exporter in un cluster con il tipo di avvio Fargate, devi anche impostare un profilo Fargate prima di eseguire la procedura descritta. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $JAR_SAMPLE_TRAFFIC_NAMESPACE\
--name $JAR_SAMPLE_TRAFFIC_NAMESPACE
```
```
kubectl exec $JAR_SAMPLE_TRAFFIC_POD -n $JARCAT_SAMPLE_TRAFFIC_NAMESPACE -- curl http://localhost:9404
```
## Esempio: immagine Docker Apache Tomcat con parametri Prometheus
Il server Apache Tomcat espone JMX mBeans per impostazione predefinita. È possibile integrare JMX Exporter con Tomcat per esporre JMX mBeans come metriche Prometheus. L'esempio seguente di file Docker mostra i passaggi per creare un'immagine di prova:
```
# From Tomcat 9.0 JDK8 OpenJDK
FROM tomcat:9.0-jdk8-openjdk
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
COPY ./setenv.sh /usr/local/tomcat/bin
COPY your web application.war /usr/local/tomcat/webapps/
RUN chmod o+x /usr/local/tomcat/bin/setenv.sh
ENTRYPOINT ["catalina.sh", "run"]
```
Nell'elenco seguente vengono illustrate le quattro righe `COPY` di questo file Docker.
+ [Scarica il file jar JMX Exporter più recente da jmx\$1exporter. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` è il file di configurazione JMX Exporter. [Per ulteriori informazioni, vedere jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Ecco un file di configurazione di esempio per Java e Tomcat:
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `setenv.sh` è uno script di startup Tomcat per avviare JMX exporter insieme a Tomcat ed esporre le metriche di Prometheus sulla porta 9404 del localhost. Fornisce inoltre al JMX Exporter il percorso del file `config.yaml`.
```
$ cat setenv.sh
export JAVA_OPTS="-javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml $JAVA_OPTS"
```
+ il tuo web application .war è il tuo file `war` dell'applicazione web che Tomcat deve caricare.
Crea un'immagine docker con questa configurazione e caricala in un repository di immagini.
## Esempio: immagine Docker dell'applicazione Java Jar con parametri Prometheus
L'esempio seguente di file Docker mostra i passaggi per creare un'immagine di prova:
```
# Alpine Linux with OpenJDK JRE
FROM openjdk:8-jre-alpine
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./SampleJavaApplication-1.0-SNAPSHOT.jar /opt/jmx_exporter
COPY ./start_exporter_example.sh /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
RUN chmod -R o+x /opt/jmx_exporter
RUN apk add curl
ENTRYPOINT exec /opt/jmx_exporter/start_exporter_example.sh
```
Nell'elenco seguente vengono illustrate le quattro righe `COPY` di questo file Docker.
+ [Scarica il file jar JMX Exporter più recente da jmx\$1exporter. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` è il file di configurazione JMX Exporter. [Per ulteriori informazioni, vedere jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Ecco un file di configurazione di esempio per Java e Tomcat:
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `start_exporter_example.sh` è lo script per avviare l'applicazione JAR con le metriche Prometheus esportate. Fornisce inoltre al JMX Exporter il percorso del file `config.yaml`.
```
$ cat start_exporter_example.sh
java -javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml -cp /opt/jmx_exporter/SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App
```
+ SampleJavaApplication-1.0-Snapshot.jar è il file jar dell'applicazione Java di esempio. Sostituirlo con l'applicazione Java che si desidera monitorare.
Crea un'immagine docker con questa configurazione e caricala in un repository di immagini.
# Configura HAProxy con un esportatore di metriche su Amazon EKS e Kubernetes
HAProxy è un'applicazione proxy open source. Per ulteriori informazioni, consulta [HAProxy](https://www.haproxy.org).
Se si utilizza un cluster con il tipo di avvio Fargate, è necessario configurare un profilo Fargate prima di eseguire i passaggi di questa procedura. HAProxy Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**Da installare HAProxy con un esportatore di metriche per testare il supporto Prometheus di Container Insights**
1. Immetti il seguente comando per aggiungere il repository dell'incubatore di Helm:
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. Immetti il seguente comando per creare un nuovo spazio di nomi:
```
kubectl create namespace haproxy-ingress-sample
```
1. Inserisci i seguenti comandi per l'installazione: HAProxy
```
helm install haproxy haproxy-ingress/haproxy-ingress \
--namespace haproxy-ingress-sample \
--set defaultBackend.enabled=true \
--set controller.stats.enabled=true \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="9101" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Immetti il seguente comando per confermare l'annotazione del servizio:
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
Dovresti vedere le annotazioni seguenti.
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**Per disinstallare HAProxy**
+ Eseguire i comandi seguenti:
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Esercitazione per l'aggiunta di una nuova destinazione di scraping di Prometheus: Redis OSS su Amazon EKS e cluster Kubernetes
Questa esercitazione offre un'introduzione pratica per recuperare le metriche Prometheus di un'applicazione Redis OSS di esempio su Amazon EKS e Kubernetes. Redis OSS (https://redis.io/) è uno store di strutture dati open source (con licenza BSD), in memoria, utilizzato come database, cache e broker di messaggi. Per ulteriori informazioni, consulta la pagina [redis](https://redis.io/).
redis\$1exporter (con licenza MIT Licence) viene utilizzato per esporre le metriche Prometheus di Redis OSS sulla porta specificata (predefinita: 0.0.0.0:9121). Per ulteriori informazioni, consulta la pagina [redis\$1exporter](https://github.com/oliver006/redis_exporter).
In questa esercitazione vengono utilizzate le immagini Docker nei due repository Docker Hub seguenti:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Per installare un carico di lavoro Redis OSS di esempio che espone le metriche Prometheus**
1. Imposta il namespace per il carico di lavoro Redis OSS di esempio.
```
REDIS_NAMESPACE=redis-sample
```
1. Se esegui Redis OSS in un cluster con il tipo di avvio Fargate, devi impostare un profilo Fargate. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. Inserisci il comando seguente per installare il carico di lavoro Redis OSS di esempio.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml \
| sed "s/{{namespace}}/$REDIS_NAMESPACE/g" \
| kubectl apply -f -
```
1. L'installazione include un servizio denominato `my-redis-metrics` che espone la metrica Prometheus di Redis OSS sulla porta 9121 Inserisci il seguente comando per ottenere informazioni sul servizio:
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
Nella `Annotations` sezione dei risultati, vedrai due annotazioni che corrispondono alla configurazione dello scrape Prometheus dell'agente, in modo che possa rilevare automaticamente CloudWatch i carichi di lavoro:
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
La configurazione di scraping di Prometheus correlata è disponibile nella sezione `- job_name: kubernetes-service-endpoints` di `kubernetes-eks.yaml` o `kubernetes-k8s.yaml`.
**Per iniziare a raccogliere le metriche di Redis OSS Prometheus in CloudWatch**
1. Scaricare la versione più recente del file `kubernetes-eks.yaml` o `kubernetes-k8s.yaml` immettendo uno dei seguenti comandi. Per un cluster Amazon EKS con tipo di avvio EC2, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Per un cluster Kubernetes in esecuzione su un'istanza Amazon EC2, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. Apri il file con un editor di testo e trova la sezione `cwagentconfig.json`. Aggiungi la seguente sottosezione e salva le modifiche. Assicurati che il rientro segua il modello esistente.
```
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
La sezione che hai aggiunto inserisce le metriche Redis OSS nell'elenco degli agenti consentiti. CloudWatch Per l'elenco di questi parametri, consulta la sezione seguente.
1. Se l' CloudWatch agente con supporto Prometheus è già distribuito in questo cluster, è necessario eliminarlo immettendo il seguente comando.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Distribuisci l' CloudWatch agente con la configurazione aggiornata immettendo uno dei seguenti comandi. Sostituisci *MyCluster* e *region* abbina le tue impostazioni.
Per un cluster Amazon EKS con tipo di avvio EC2, inserisci questo comando.
```
kubectl apply -f prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, inserisci questo comando.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Per un cluster Kubernetes, inserisci il seguente comando.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Visualizzazione delle metriche Prometheus di Redis OSS
Questo tutorial invia le seguenti metriche allo spazio dei nomi **ContainerInsights/Prometheus** in. CloudWatch Puoi usare la CloudWatch console per visualizzare le metriche in quel namespace.
| Nome parametro | Dimensioni |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName, `Namespace` |
| `redis_net_output_bytes_total` | ClusterName, `Namespace` |
| `redis_expired_keys_total` | ClusterName, `Namespace` |
| `redis_evicted_keys_total` | ClusterName, `Namespace` |
| `redis_keyspace_hits_total` | ClusterName, `Namespace` |
| `redis_keyspace_misses_total` | ClusterName, `Namespace` |
| `redis_memory_used_bytes` | ClusterName, `Namespace` |
| `redis_connected_clients` | ClusterName, `Namespace` |
| `redis_commands_total` | ClusterName,, cmd `Namespace` |
| `redis_db_keys` | ClusterName, `Namespace` db |
**Nota**
Il valore della dimensione **cmd** può essere `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` o `slowlog`.
Il valore della dimensione **db** può essere da `db0` a `db15`.
Puoi anche creare una CloudWatch dashboard per le metriche di Redis OSS Prometheus.
**Per creare un pannello di controllo per le metriche Prometheus di Redis OSS**
1. Crea variabili di ambiente, sostituendo i valori sotto in modo che corrispondano all'implementazione.
```
DASHBOARD_NAME=your_cw_dashboard_name
REGION_NAME=your_metric_region_such_as_us-east-1
CLUSTER_NAME=your_k8s_cluster_name_here
NAMESPACE=your_redis_service_namespace_here
```
1. Inserisci il seguente comando per creare il pannello di controllo.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```
# Conversione del tipo di metrica Prometheus da parte dell'agente CloudWatch
Le librerie client Prometheus offrono quattro tipi di parametri principali:
+ Contatore
+ Misuratore
+ Riepilogo
+ Istogramma
L' CloudWatch agente supporta i tipi di metriche counter, gauge e summary.
Le metriche Prometheus con il tipo di metrica istogramma non supportato vengono eliminate dall'agente. CloudWatch Per ulteriori informazioni, consulta [Registrazione dei parametri Prometheus eliminati](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics).
**Parametri misuratore**
Un parametro misuratore Prometheus è un parametro che rappresenta un singolo valore numerico che può aumentare o diminuire arbitrariamente. L' CloudWatch agente analizza le metriche degli indicatori e invia direttamente questi valori.
**Metriche dei contatori**
Un parametro contatore Prometheus è un parametro cumulativo che rappresenta un singolo contatore che cresce monotonicamente, il cui valore può solo aumentare o essere reimpostato a zero. L' CloudWatch agente calcola un delta dallo scrape precedente e invia il valore delta come valore metrico nell'evento di registro. Quindi l' CloudWatch agente inizierà a produrre un evento di registro dal secondo scrape e continuerà con gli scrape successivi, se presenti.
**Parametri di riepilogo**
Un parametro di riepilogo Prometheus è un tipo di parametro complesso rappresentato da più punti dati. Offre un conteggio totale delle osservazioni e una somma di tutti i valori osservati. Calcola quantili configurabili su una finestra temporale scorrevole.
La somma e il conteggio di un parametro di riepilogo sono cumulativi, ma i quantili non lo sono. L'esempio seguente mostra la varianza dei quantili.
```
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 7.123e-06
go_gc_duration_seconds{quantile="0.25"} 9.204e-06
go_gc_duration_seconds{quantile="0.5"} 1.1065e-05
go_gc_duration_seconds{quantile="0.75"} 2.8731e-05
go_gc_duration_seconds{quantile="1"} 0.003841496
go_gc_duration_seconds_sum 0.37630427
go_gc_duration_seconds_count 9774
```
L' CloudWatch agente gestisce la somma e il conteggio di una metrica di riepilogo nello stesso modo in cui gestisce le metriche dei contatori, come descritto nella sezione precedente. L' CloudWatch agente conserva i valori quantili così come sono stati originariamente riportati.
# Metriche di Prometheus raccolte dall'agente CloudWatch
L' CloudWatch agente con supporto Prometheus raccoglie automaticamente le metriche da diversi servizi e carichi di lavoro. Nelle sezioni seguenti sono elencati i parametri raccolti per impostazione predefinita. È inoltre possibile configurare l'agente per raccogliere altri parametri da questi servizi e per raccogliere parametri Prometheus da altri applicazioni e servizi. Per ulteriori informazioni sulla raccolta di parametri aggiuntivi, consulta [CloudWatch configurazione dell'agente per Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config).
**Le metriche di Prometheus raccolte dai cluster Amazon EKS e Kubernetes si trovano nello spazio dei nomi /Prometheus. ContainerInsights** Le metriche di Prometheus raccolte dai cluster Amazon ECS si trovano nel namespace. **ECS/ContainerInsights/Prometheus**
**Topics**
+ [Parametri Prometheus per App Mesh](#ContainerInsights-Prometheus-metrics-appmesh)
+ [Parametri Prometheus per NGINX](#ContainerInsights-Prometheus-metrics-nginx)
+ [Parametri Prometheus per Memcached](#ContainerInsights-Prometheus-metrics-memcached)
+ [Parametri Prometheus per Java/JMX](#ContainerInsights-Prometheus-metrics-jmx)
+ [Metriche Prometheus per HAProxy](#ContainerInsights-Prometheus-metrics-haproxy)
## Parametri Prometheus per App Mesh
I seguenti parametri vengono raccolti automaticamente da App Mesh.
**Parametri Prometheus per App Mesh su cluster Amazon EKS e Kubernetes**
| Nome parametro | Dimensioni |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName, `Namespace` |
| `envoy_http_downstream_rq_xx` | ClusterName, `Namespace` ClusterName, `Namespace` envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `Namespace` |
| `envoy_cluster_membership_healthy` | ClusterName, `Namespace` |
| `envoy_cluster_membership_total` | ClusterName, `Namespace` |
| `envoy_server_memory_heap_size` | ClusterName, `Namespace` |
| `envoy_server_memory_allocated` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName, `Namespace` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `Namespace` |
| `envoy_server_live` | ClusterName, `Namespace` |
| `envoy_server_uptime` | ClusterName, `Namespace` |
**Parametri Prometheus per App Mesh su cluster Amazon ECS**
| Nome parametro | Dimensioni |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_membership_healthy` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_membership_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_memory_heap_size` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_memory_allocated` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName, `TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_live` | ClusterName, `TaskDefinitionFamily` |
| `envoy_server_uptime` | ClusterName, `TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName TaskDefinitionFamily, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class ClusterName TaskDefinitionFamily, envoy\$1response\$1code\$1class |
**Nota**
`TaskDefinitionFamily` è lo spazio dei nomi Kubernetes della mesh.
Il valore di `envoy_http_conn_manager_prefix` può essere `ingress`, `egress` o `admin`.
Il valore di `envoy_response_code_class` può essere `1` (sta per `1xx`), `2` (sta per `2xx`), `3` (sta per `3xx`), `4` (sta per `4xx`) o `5` (sta per `5xx`).
## Parametri Prometheus per NGINX
I seguenti parametri vengono raccolti automaticamente da NGINX su cluster Amazon EKS e Kubernetes.
| Nome parametro | Dimensioni |
| --- | --- |
| `nginx_ingress_controller_nginx_process_cpu_seconds_total` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_success` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_requests` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_connections` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_connections_total` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_nginx_process_resident_memory_bytes` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_config_last_reload_successful` | ClusterName, `Namespace`, Service |
| `nginx_ingress_controller_requests` | ClusterName`Namespace`,, Servizio, stato |
## Parametri Prometheus per Memcached
I seguenti parametri vengono raccolti automaticamente da Memcached su cluster Amazon EKS e Kubernetes.
| Nome parametro | Dimensioni |
| --- | --- |
| `memcached_current_items` | ClusterName, `Namespace`, Service |
| `memcached_current_connections` | ClusterName, `Namespace`, Service |
| `memcached_limit_bytes` | ClusterName, `Namespace`, Service |
| `memcached_current_bytes` | ClusterName, `Namespace`, Service |
| `memcached_written_bytes_total` | ClusterName, `Namespace`, Service |
| `memcached_read_bytes_total` | ClusterName, `Namespace`, Service |
| `memcached_items_evicted_total` | ClusterName, `Namespace`, Service |
| `memcached_items_reclaimed_total` | ClusterName, `Namespace`, Service |
| `memcached_commands_total` | ClusterName, `Namespace`, Service ClusterName,`Namespace`, Service, comando ClusterName,`Namespace`, Servizio, stato, comando |
## Parametri Prometheus per Java/JMX
**Parametri raccolti sui cluster Amazon EKS e Kubernetes**
Sui cluster Amazon EKS e Kubernetes, Container Insights può raccogliere le seguenti parametri Prometheus predefinite da Java Virtual Machine (JVM), Java e Tomcat (Catalina) utilizzando JMX Exporter. Per ulteriori informazioni, vedere [ prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) su Github.
**Java/JMX su cluster Amazon EKS e Kubernetes**
| Nome parametro | Dimensioni |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `Namespace` |
| `jvm_threads_current` | `ClusterName`, `Namespace` |
| `jvm_threads_daemon` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `Namespace` |
| `jvm_memory_bytes_used` | `ClusterName`, `Namespace`, area |
| `jvm_memory_pool_bytes_used` | `ClusterName`, `Namespace`, pool |
**Nota**
I valori della dimensione `area` possono essere `heap` o `nonheap`.
I valori della dimensione `pool` possono essere `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` o `Metaspace`.
**Tomcat/JMX su cluster Amazon EKS e Kubernetes**
Oltre alle Java/JMX metriche della tabella precedente, vengono raccolte anche le seguenti metriche per il carico di lavoro Tomcat.
| Nome parametro | Dimensioni |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `Namespace` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `Namespace` |
**Java/JMX su cluster Amazon ECS**
| Nome parametro | Dimensioni |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_current` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_daemon` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_memory_bytes_used` | `ClusterName`,, area TaskDefinitionFamily |
| `jvm_memory_pool_bytes_used` | `ClusterName` TaskDefinitionFamily, piscina |
**Nota**
I valori della dimensione `area` possono essere `heap` o `nonheap`.
I valori della dimensione `pool` possono essere `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` o `Metaspace`.
**Tomcat/JMX su cluster Amazon ECS**
Oltre ai Java/JMX parametri della tabella precedente, vengono raccolti anche i seguenti parametri per il carico di lavoro Tomcat sui cluster Amazon ECS.
| Nome parametro | Dimensioni |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `TaskDefinitionFamily` |
## Metriche Prometheus per HAProxy
Le seguenti metriche vengono raccolte automaticamente dai cluster HAProxy Amazon EKS e Kubernetes.
Le metriche raccolte dipendono dalla versione di Ingress in uso HAProxy . [Per ulteriori informazioni su HAProxy Ingress e le sue versioni, vedere haproxy-ingress.](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress)
| Nome parametro | Dimensioni | Disponibilità |
| --- | --- | --- |
| `haproxy_backend_bytes_in_total` | `ClusterName`, `Namespace`, Service | Tutte HAProxy le versioni di Ingress |
| `haproxy_backend_bytes_out_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_backend_connection_errors_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_backend_connections_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_backend_current_sessions` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_backend_http_responses_total` | `ClusterName`, `Namespace`, Service, code, backend | Tutte le versioni di Ingress HAProxy |
| `haproxy_backend_status` | `ClusterName`, `Namespace`, Service | Solo nelle versioni 0.10 o successive di Ingress HAProxy |
| `haproxy_backend_up` | `ClusterName`, `Namespace`, Service | Solo nelle versioni di HAProxy Ingress precedenti alla 0.10 |
| `haproxy_frontend_bytes_in_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_bytes_out_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_connections_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_current_sessions` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_http_requests_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_http_responses_total` | `ClusterName`, `Namespace`, Service, code, frontend | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_request_errors_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
| `haproxy_frontend_requests_denied_total` | `ClusterName`, `Namespace`, Service | Tutte le versioni di Ingress HAProxy |
**Nota**
I valori della dimensione `code` possono essere `1xx`, `2xx`, `3xx`, `4xx`, `5xx` o `other`.
I valori della dimensione `backend` possono essere:
`http-default-backend``http-shared-backend`, o `httpsback-shared-backend` per la versione HAProxy 0.0.27 di Ingress o precedente.
`_default_backend`per versioni di HAProxy Ingress successive alla 0.0.27.
I valori della dimensione `frontend` possono essere:
`httpfront-default-backend``httpfront-shared-frontend`, o `httpfronts` per la versione 0.0.27 HAProxy di Ingress o precedente.
`_front_http`o `_front_https` per le versioni di HAProxy Ingress successive alla 0.0.27.
# Visualizzazione dei parametri Prometheus
Puoi monitorare e generare allarmi in base a tutte le tue metriche Prometheus, incluse le metriche preaggregate curate di App Mesh, NGINX, Java/JMX, Memcached e qualsiasi altro esportatore Prometheus configurato manualmente che potresti aver aggiunto. HAProxy Per ulteriori informazioni sulla raccolta di metriche da altri esportatori di Prometheus, vedere [Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).
Nella console, Container Insights fornisce i seguenti report predefiniti: CloudWatch
+ Per i cluster Amazon EKS e Kubernetes, ci sono report predefiniti per App Mesh, NGINX, HAPROXY, Memcached e Java/JMX.
+ Per i cluster Amazon ECS, ci sono report predefiniti per App Mesh e Java/JMX.
Container Insights offre inoltre pannelli di controllo personalizzati per ciascuno dei carichi di lavoro da cui Container Insights raccoglie parametri curati. Puoi scaricare questi dashboard da GitHub
**Per visualizzare tutte le metriche Prometheus**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione, seleziona **Parametri**.
1. **Nell'elenco dei namespace, scegli ContainerInsights /Prometheus o. **ECS/ContainerInsights/Prometheus****
1. Scegliete uno degli insiemi di quote nell'elenco seguente. Seleziona quindi la casella di controllo accanto alle metriche che desideri visualizzare.
**Per visualizzare report predefiniti sulle metriche di Prometheus**
1. CloudWatch Apri [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)la console all'indirizzo.
1. Nel riquadro di navigazione scegli **Monitoraggio delle performance**.
1. Nella casella a discesa nella parte superiore della pagina, scegli una delle opzioni Prometheus.
Nell'altra casella a discesa scegliere un cluster da visualizzare
Abbiamo anche fornito dashboard personalizzati per NGINX, App Mesh, Memcached e Java/JMX. HAProxy
**Per utilizzare un pannello di controllo personalizzato fornito da Amazon**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)Apri CloudWatch la console all'indirizzo.
1. Nel pannello di navigazione seleziona **Dashboards** (Pannelli di controllo).
1. Scegli **Crea pannello di controllo)**. Immetti un nome per il nuovo dashboard e scegli **Crea dashboard**.
1. In **Add to this dashboard** (Aggiungi a questo pannello di controllo), scegli **Cancel** (Annulla).
1. Seleziona **Actions (Operazioni)**, **View/edit source (Visualizza/modifica origine)**.
1. Scaricare uno dei seguenti file JSON:
+ [ Origine pannello di controllo personalizzato NGINX su Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json).
+ [ Origine pannello di controllo personalizzato App Mesh su Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json).
+ [Origine pannello di controllo personalizzato Memcached su Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json)
+ [ HAProxy-Inserisci il codice sorgente personalizzato della dashboard su Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json)
+ [ Java/JMX sorgente dashboard personalizzata su Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.json).
1. Apri il file JSON scaricato con un editor di testo e apporta le seguenti modifiche:
+ Sostituire tutte le stringhe `{{YOUR_CLUSTER_NAME}}` con il nome esatto del cluster. Assicurarti di non aggiungere spazi bianchi prima o dopo il testo.
+ Sostituisci tutte le `{{YOUR_REGION}}` stringhe con la AWS regione in cui è in esecuzione il cluster. Ad esempio, **us-west-1** Assicurati di non aggiungere spazi bianchi prima o dopo il testo.
+ Sostituisci tutte le stringhe `{{YOUR_NAMESPACE}}` con lo spazio dei nomi esatto del carico di lavoro.
+ Sostituisci tutte le stringhe `{{YOUR_SERVICE_NAME}}` con il nome del servizio esatto del carico di lavoro. Ad esempio, **haproxy-haproxy-ingress-controller-metrics**
1. Copia l'intero blob JSON e incollalo nella casella di testo della CloudWatch console, sostituendo ciò che è già presente nella casella.
1. Scegli **Update** (Aggiorna), **Save dashboard** (Salva pannello di controllo).
# Risoluzione dei problemi relativi ai parametri Prometheus
Questa sezione fornisce informazioni sulla risoluzione dei problemi relativi all'impostazione delle metriche di Prometheus.
**Topics**
+ [Risoluzione dei problemi relativi ai parametri Prometheus su Amazon ECS](ContainerInsights-Prometheus-troubleshooting-ECS.md)
+ [Risoluzione dei problemi dei parametri Prometheus sui cluster Amazon EKS e Kubernetes](ContainerInsights-Prometheus-troubleshooting-EKS.md)
# Risoluzione dei problemi relativi ai parametri Prometheus su Amazon ECS
Questa sezione offre informazioni sulla risoluzione dei problemi relativi all'impostazione dei parametri di Prometheus su cluster Amazon ECS.
## Non vedo le metriche di Prometheus inviate a Logs CloudWatch
**Le metriche di Prometheus devono essere inserite come eventi di registro nel gruppo di log/. aws/ecs/containerinsights/cluster-name/Prometheus** Se il gruppo di log non viene creato o le metriche di Prometheus non vengono inviate al gruppo di log, è necessario innanzitutto verificare se gli obiettivi Prometheus sono stati scoperti con successo dall'agente. CloudWatch Quindi controlla il gruppo di sicurezza e le impostazioni di autorizzazione dell'agente. CloudWatch I seguenti passaggi guidano l'utente per eseguire il debug.
**Passaggio 1: abilitare la modalità di debug CloudWatch dell'agente**
Innanzitutto, imposta l' CloudWatch agente in modalità di debug aggiungendo le seguenti righe in grassetto al file CloudFormation modello, oppure. `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` Quindi salvare il file.
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
Crea un nuovo CloudFormation changeset rispetto allo stack esistente. Imposta gli altri parametri nel changeset sugli stessi valori dello stack esistente. CloudFormation L'esempio seguente riguarda un CloudWatch agente installato in un cluster Amazon ECS utilizzando il tipo di avvio EC2 e la modalità di rete bridge.
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
NEW_CHANGESET_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name $NEW_CHANGESET_NAME
```
Vai alla CloudFormation console per esaminare il nuovo changeset,. `$NEW_CHANGESET_NAME` Dovrebbe essere applicata una modifica alla risorsa **CWAgentConfig. SSMParameter** Esegui il changeset e riavvia l'attività dell' CloudWatch agente immettendo i seguenti comandi.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service your_service_name_here \
--region $AWS_REGION
```
Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service your_service_name_here \
--region $AWS_REGION
```
**Passaggio 2: controllo dei log di individuazione del servizio ECS**
La definizione del task ECS dell' CloudWatch agente abilita i log per impostazione predefinita nella sezione seguente. **I log vengono inviati a Logs nel gruppo di CloudWatch log /ecs/. ecs-cwagent-prometheus**
```
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-create-group: 'True'
awslogs-group: "/ecs/ecs-cwagent-prometheus"
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc'
```
Filtra i log in base alla stringa `ECS_SD_Stats` per ottenere i parametri relativi all'individuazione dei servizi ECS, come mostrato nell'esempio seguente.
```
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms
```
Il significato di ogni parametro per un particolare ciclo di individuazione dei servizi ECS è il seguente:
+ **AWSCLI\$1DescribeContainerInstances**— il numero di chiamate API effettuate. `ECS::DescribeContainerInstances`
+ **AWSCLI\$1DescribeInstancesRequest**— il numero di chiamate `ECS::DescribeInstancesRequest` API effettuate.
+ **AWSCLI\$1DescribeTaskDefinition**— il numero di chiamate `ECS::DescribeTaskDefinition` API effettuate.
+ **AWSCLI\$1DescribeTasks**— il numero di chiamate `ECS::DescribeTasks` API effettuate.
+ **AWSCLI\$1ListTasks**— il numero di chiamate `ECS::ListTasks` API effettuate.
+ **ExporterDiscoveredTargetCount**— il numero di obiettivi Prometheus che sono stati scoperti ed esportati con successo nel file dei risultati di destinazione all'interno del contenitore.
+ **LRUCache\$1Get\$1 EC2 MetaData**: il numero di volte in cui i metadati delle istanze del contenitore sono stati recuperati dalla cache.
+ **LRUCache\$1Get\$1 TaskDefinition**: il numero di volte in cui i metadati di definizione delle attività ECS sono stati recuperati dalla cache.
+ **LRUCache\$1Size\$1 ContainerInstance**: il numero di metadati di un'istanza di contenitore univoca memorizzati nella cache.
+ **LRUCache\$1Size\$1 TaskDefinition**: il numero di definizioni di attività ECS univoche memorizzate nella cache.
+ **Latency** (Latenza): quanto tempo richiede il ciclo di individuazione dei servizi.
Verifica il valore di `ExporterDiscoveredTargetCount` per vedere se le destinazioni Prometheus individuate corrispondono alle tue aspettative. In caso contrario, i possibili motivi sono i seguenti:
+ La configurazione dell'individuazione del servizio ECS potrebbe non corrispondere all'impostazione dell'applicazione. Per il rilevamento dei servizi basati su etichette docker, i contenitori di destinazione potrebbero non avere l'etichetta docker necessaria configurata nell'agente CloudWatch per individuarli automaticamente. Per la definizione delle attività ARN Regular Expression-based service discovery di ECS, l'impostazione regex nell'agente potrebbe non corrispondere CloudWatch alla definizione dell'attività dell'applicazione.
+ Il ruolo del task ECS dell' CloudWatch agente potrebbe non disporre dell'autorizzazione per recuperare i metadati delle attività ECS. Verifica che all' CloudWatch agente siano state concesse le seguenti autorizzazioni di sola lettura:
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
**Passaggio 3: controllo della connessione di rete e delle policy dei ruoli delle attività ECS**
Se non ci sono ancora eventi di registro inviati al gruppo di log CloudWatch Logs di destinazione, anche se il valore di `Exporter_DiscoveredTargetCount` indica che sono stati scoperti obiettivi Prometheus, ciò potrebbe essere causato da una delle seguenti cause:
+ L' CloudWatch agente potrebbe non essere in grado di connettersi alle porte di destinazione Prometheus. Controlla l'impostazione del gruppo di sicurezza dietro l'agente. CloudWatch L'IP privato dovrebbe consentire all' CloudWatch agente di connettersi alle porte dell'esportatore Prometheus.
+ Il ruolo del task ECS dell' CloudWatch agente potrebbe non avere la policy gestita. **CloudWatchAgentServerPolicy** Il task role ECS dell' CloudWatchagente deve avere questa politica per poter inviare le metriche di Prometheus come eventi di registro. Se hai utilizzato il CloudFormation modello di esempio per creare automaticamente i ruoli IAM, sia il ruolo di attività ECS che il ruolo di esecuzione ECS dispongono del privilegio minimo per eseguire il monitoraggio di Prometheus.
# Risoluzione dei problemi dei parametri Prometheus sui cluster Amazon EKS e Kubernetes
Questa sezione offre informazioni sulla risoluzione dei problemi relativi all'impostazione dei parametri di Prometheus su cluster Amazon EKS e Kubernetes.
## Procedura per la risoluzione dei problemi su Amazon EKS
Per confermare che l' CloudWatch agente è in esecuzione, inserisci il seguente comando.
```
kubectl get pod -n amazon-cloudwatch
```
L'output dovrebbe includere una riga con `cwagent-prometheus-id` nella colonna `NAME` e `Running` nel campo `STATUS column.`
Per visualizzare i dettagli sul pod in esecuzione, immetti il seguente comando. Sostituiscilo *pod-name* con il nome completo del pod il cui nome inizia con`cw-agent-prometheus`.
```
kubectl describe pod pod-name -n amazon-cloudwatch
```
Se hai installato CloudWatch Container Insights, puoi utilizzare CloudWatch Logs Insights per interrogare i log dell' CloudWatch agente che raccoglie le metriche di Prometheus.
**Per eseguire query sui log delle applicazioni**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)Apri la console all'indirizzo. CloudWatch
1. Nel riquadro di navigazione, scegli **CloudWatch Logs Insights.**
1. **Seleziona il gruppo di log per i log dell'applicazione, /aws/containerinsights/ /application *cluster-name***
1. Sostituisci l'espressione di query di ricerca con la query seguente e scegli **Esegui query**
```
fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log |
filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus
```
Puoi anche confermare che le metriche e i metadati di Prometheus vengano inseriti come eventi di log. CloudWatch
**Per confermare che i dati di Prometheus vengano ingeriti**
1. Apri CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)la console all'indirizzo.
1. Nel riquadro di navigazione, scegli **CloudWatch Logs Insights.**
1. Seleziona **/aws/containerinsights/ /prometheus *cluster-name***
1. Sostituisci l'espressione di query di ricerca con la query seguente e scegli **Esegui query**
```
fields @timestamp, @message | sort @timestamp desc | limit 20
```
## Registrazione dei parametri Prometheus eliminati
Questa versione non raccoglie i parametri Prometheus di tipo istogramma. Puoi utilizzare l' CloudWatch agente per verificare se alcune metriche di Prometheus vengono eliminate perché si tratta di metriche di istogrammi. Puoi anche registrare un elenco delle prime 500 metriche di Prometheus che vengono eliminate e non CloudWatch inviate a nessuno perché si tratta di metriche di istogrammi.
Per verificare se vengono eliminate le metriche, immetti il seguente comando:
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
Se vengono eliminate delle metriche, nel file `/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log` verranno visualizzate le seguenti righe.
```
I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported.
I! Please enable CWAgent debug mode to view the first 500 dropped metrics
```
Se vedi queste righe e vuoi sapere quali metriche vengono eliminate, segui la procedura seguente.
**Per registrare un elenco delle parametri di Prometheus eliminati**
1. Imposta l' CloudWatch agente in modalità debug aggiungendo le seguenti righe in grassetto al file `prometheus-eks.yaml` or `prometheus-k8s.yaml` e salva il file.
```
{
"agent": {
"debug": true
},
```
Questa sezione del file dovrebbe quindi assomigliare a questa:
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
1. Reinstalla l' CloudWatch agente per abilitare la modalità di debug inserendo i seguenti comandi:
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
kubectl apply -f prometheus.yaml
```
Le metriche eliminate vengono registrate nel pod dell'agente. CloudWatch
1. Per recuperare i log dal contenitore dell' CloudWatch agente, immettete il seguente comando:
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
**Oppure, se hai installato la registrazione di Container Insights Fluentd, i log vengono salvati anche nel gruppo di log Logs /aws/containerinsights/ /application. CloudWatch *cluster\$1name***
Per eseguire una query su questi registri, è possibile seguire la procedura per eseguire query sui log dell'applicazione in [Procedura per la risoluzione dei problemi su Amazon EKS](#ContainerInsights-Prometheus-troubleshooting-general).
## Dove vengono inserite le metriche di Prometheus come eventi di log log? CloudWatch
L' CloudWatch agente crea un flusso di log per ogni configurazione dello scrape job di Prometheus. Ad esempio, nei file `prometheus-eks.yaml` e `prometheus-k8s.yaml`, la riga `job_name: 'kubernetes-pod-appmesh-envoy'` recupera i parametri App Mesh. Il target di Prometheus è definito come `kubernetes-pod-appmesh-envoy`. **Quindi tutte le metriche di App Mesh Prometheus vengono inserite come eventi di log nel flusso di log nel gruppo di log CloudWatch denominato/. **kubernetes-pod-appmesh-envoy**aws/containerinsights/cluster-name/Prometheus**
## Non vedo i parametri di Amazon EKS o Kubernetes Prometheus nelle metriche CloudWatch
**Innanzitutto, assicurati che le metriche di Prometheus vengano inserite come eventi di registro nel gruppo di log/. aws/containerinsights/cluster-name/Prometheus** Utilizzare le informazioni in [Dove vengono inserite le metriche di Prometheus come eventi di log log? CloudWatch](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested) per controllare il flusso di log di destinazione. Se il flusso di log non viene creato o non ci sono nuovi eventi di log nel flusso di log, verificare quanto segue:
+ Verificare che gli endpoint di esportazione delle metriche Prometheus siano impostati correttamente
+ Verifica che le configurazioni di scraping di Prometheus nella sezione del file YAML `config map: cwagent-prometheus` dell'agente siano corrette. CloudWatch La configurazione dovrebbe essere la stessa di un file di configurazione di Prometheus. Per ulteriori informazioni, vedere [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) nella documentazione di Prometheus.
Se le metriche di Prometheus vengono inserite correttamente come eventi di registro, verifica che le impostazioni del formato metrico incorporato vengano aggiunte agli eventi di registro per generare le metriche. CloudWatch
```
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"envoy_http_downstream_cx_destroy_remote_active_rq"
}
],
"Dimensions":[
[
"ClusterName",
"Namespace"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
```
Per ulteriori informazioni sul formato della metrica incorporata, vedere [Specifica: Embedded Metric Format](CloudWatch_Embedded_Metric_Format_Specification.md).
Se non è presente un formato metrico incorporato negli eventi di registro, verifica che la `metric_declaration` sezione sia configurata correttamente nella sezione del file YAML di installazione dell'agente. `config map: prometheus-cwagentconfig` CloudWatch Per ulteriori informazioni, consulta [Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).