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à.

# (Facoltativo) Impostazione dei carichi di lavoro Amazon ECS containerizzati di esempio per i test dei parametri di Prometheus
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh-uninstall"></a>

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
<a name="ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx"></a>

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
<a name="ContainerInsights-Prometheus-Setup-nginx-ecs"></a>

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
<a name="ContainerInsights-Prometheus-nginx-ecs-setup"></a>

Procedi come segue per installare il carico di lavoro di esempio del proxy inverso NGINX.

### Creazione delle immagini Docker
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-docker"></a>

**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
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-task"></a>

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
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-agent"></a>

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
<a name="ContainerInsights-Prometheus-Setup-nginx-view"></a>

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
<a name="ContainerInsights-Prometheus-Setup-nginx-plus-ecs"></a>

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
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup"></a>

Procedi come segue per installare il carico di lavoro di esempio del proxy inverso NGINX.

### Creazione delle immagini Docker
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-docker"></a>

**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 <docker-maint@nginx.com>“
     
     # 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
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-task"></a>

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
<a name="ContainerInsights-Prometheus-nginx-plus-ecs-setup-agent"></a>

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
<a name="ContainerInsights-Prometheus-Setup-nginx-plus-view"></a>

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
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs"></a>

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
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-environment"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-memcached-ecs-agent"></a>

**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
<a name="ContainerInsights-Prometheus-ECS-memcached-view"></a>

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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs"></a>

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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable2"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-install-workload"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-agent"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-view"></a>

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" \
   ```