

# Carga de trabajo NGINX de muestra para clústeres de Amazon ECS
<a name="ContainerInsights-Prometheus-Setup-nginx-ecs"></a>

El exportador NGINX de Prometheus puede raspar y exponer datos NGINX como métricas de Prometheus. En este ejemplo se utiliza el exportador junto con el servicio proxy inverso NGINX para Amazon ECS.

Para obtener más información sobre el exportador NGINX de Prometheus, consulte [nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) en Github. Para obtener más información sobre el proxy inverso NGINX, consulte [ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy) en Github.

El agente de CloudWatch compatible con Prometheus raspa las métricas de NGINX de Prometheus basadas en la configuración de detección de servicios en el clúster de Amazon ECS. Puede configurar el exportador NGINX de Prometheus para exponer las métricas en un puerto o una ruta diferente. Si cambia el puerto o la ruta, actualice la sección `ecs_service_discovery` en el archivo de configuración del agente de CloudWatch.

## Instale la carga de trabajo de muestra del proxy inverso NGINX para clústeres de Amazon ECS
<a name="ContainerInsights-Prometheus-nginx-ecs-setup"></a>

Siga los pasos para instalar la carga de trabajo de muestra del proxy inverso NGINX.

### Cree las imágenes de Docker
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-docker"></a>

**Para crear las imágenes de Docker para la carga de trabajo de muestra del proxy inverso NGINX**

1. Descargue la siguiente carpeta del repositorio proxy inverso NGINX: [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/).

1. Busque el directorio de la `app` y cree una imagen desde ese directorio:

   ```
   docker build -t web-server-app ./{{path-to-app-directory}}
   ```

1. Cree una imagen personalizada para NGINX. Primero, cree un directorio con los dos siguientes archivos:
   + Un archivo Dockerfile de muestra:

     ```
     FROM nginx
     COPY nginx.conf /etc/nginx/nginx.conf
     ```
   + Un archivo `nginx.conf`, modificado desde [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](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` debe estar habilitado en el mismo puerto que `nginx-prometheus-exporter` está configurado para raspar métricas desde allí. En nuestra definición de tarea de ejemplo, `nginx-prometheus-exporter` está configurado para raspar métricas del puerto 8080.

1. Cree una imagen a partir de archivos en el directorio nuevo:

   ```
   docker build -t nginx-reverse-proxy ./{{path-to-your-directory}}
   ```

1. Cargue las imágenes nuevas en un repositorio de imágenes para usarlas posteriormente.

### Cree la definición de tarea para ejecutar NGINX y la aplicación de servidor web en Amazon ECS
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-task"></a>

A continuación, se debe configurar la definición de tarea.

Esta definición de tarea permite la recopilación y exportación de métricas de NGINX de Prometheus. El contenedor NGINX realiza un seguimiento de la entrada desde la aplicación y expone esos datos al puerto 8080, como se establece en `nginx.conf`. El contenedor exportador NGINX de Prometheus raspa estas métricas y las publica en el puerto 9113, para usarlas en CloudWatch.

**Para configurar la definición de tarea para la carga de trabajo de muestra de NGINX de Amazon ECS**

1. Cree un archivo de definición de tarea JSON con el siguiente contenido. Reemplace {{your-customized-nginx-iamge}} con el URI de imagen para la imagen NGINX personalizada y reemplace {{your-web-server-app-image}} con el URI de imagen para la imagen de la aplicación del servidor 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. Ingrese el siguiente comando para registrar la definición de tarea.

   ```
   aws ecs register-task-definition --cli-input-json file://{{path-to-your-task-definition-json}}
   ```

1. Cree un servicio para ejecutar la tarea mediante el siguiente comando:

   Asegúrese de no cambiar el nombre del servicio. Se ejecutará un servicio del agente de CloudWatch con una configuración que busca tareas mediante los patrones de nombres de los servicios que las iniciaron. Por ejemplo, para que el agente de CloudWatch encuentre la tarea que este comando ha lanzado, puede especificar que el valor de `sd_service_name_pattern` sea `^nginx-service$`. En la siguiente sección se proporcionan más detalles.

   ```
   aws ecs create-service \
    --cluster {{your-cluster-name}} \
    --service-name nginx-service \
    --task-definition nginx-sample-stack:1 \
    --desired-count 1
   ```

### Configure el agente de CloudWatch para que realice el raspado de las métricas de NGINX Prometheus
<a name="ContainerInsights-Prometheus-nginx-ecs-setup-agent"></a>

El paso final es configurar el agente de CloudWatch para que realice el raspado de las métricas de NGINX. En este ejemplo, el agente de CloudWatch detecta la tarea mediante el patrón de nombre de servicio y el puerto 9113, donde el exportador expone las métricas de prometheus para NGINX. Con la tarea detectada y las métricas disponibles, el agente de CloudWatch comienza a publicar las métricas recopiladas en el flujo de registro **nginx-prometheus-exporter**. 

**Para configurar el agente de CloudWatch para que realice el raspado de las métricas de NGINX**

1. Descargue la última versión del archivo YAML necesario con el siguiente 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. Abra el archivo con un editor de texto y busque la configuración completa del agente CloudWatch en la clave de `value` en la sección `resource:CWAgentConfigSSMParameter`. A continuación, en la sección `ecs_service_discovery`, agregue la siguiente sección `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. En el mismo archivo, agregue la siguiente sección en la sección `metric_declaration` para permitir las métricas de NGINX. Asegúrese de seguir el patrón de sangría existente.

   ```
   {
     "source_labels": ["job"],
     "label_matcher": ".*nginx.*",
     "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
     "metric_selectors": [
       "^nginx_.*$"
     ]
   },
   ```

1. Si aún no tiene el agente de CloudWatch implementado en este clúster, diríjase directamente al paso 8.

   Si ya implementó el agente de CloudWatch en el clúster de Amazon ECS mediante AWS CloudFormation, puede crear un conjunto de cambios con los siguientes comandos:

   ```
   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. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Revise el conjunto de cambios recién creado **nginx-scraping-support**. Se debería ver un cambio aplicado al recurso **CWAgentConfigSSMParameter**. Ejecute el conjunto de cambios y reinicie la tarea del agente de CloudWatch con el siguiente 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. Espere aproximadamente 10 segundos y, a continuación, ingrese el siguiente comando.

   ```
   aws ecs update-service --cluster $ECS_CLUSTER_NAME \
   --desired-count 1 \
   --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
   --region $AWS_REGION
   ```

1. Si va a instalar el agente de CloudWatch con la recopilación de métricas de Prometheus en el clúster por primera vez, ingrese los siguientes comandos.

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

## Visualización de las métricas y los registros de NGINX
<a name="ContainerInsights-Prometheus-Setup-nginx-view"></a>

Ahora puede ver las métricas de NGINX que se están recopilando.

**Para visualizar las métricas de la carga de trabajo de muestra de NGINX**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En la Región en la que se está ejecutando el clúster, elija **Metrics** (Métricas) en el panel de navegación izquierdo. Busque el espacio de nombres **ContainerInsights/Prometheus** para ver las métricas.

1. Para ver los eventos de CloudWatch Logs, elija **Log groups** (Grupos de registros) en el panel de navegación. Los eventos se encuentran en el grupo de registros **/aws/containerinsights/{{your\_cluster\_name}}/prometheus**, en el flujo de registros {{nginx-prometheus-exporter}}.