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