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à.
# 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" \
```