Instale la carga de trabajo de muestra del proxy inverso NGINX para clústeres de Amazon ECS Visualización de las métricas y los registros de NGINX

Carga de trabajo NGINX de muestra para clústeres de Amazon ECS

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 en Github. Para obtener más información sobre el proxy inverso NGINX, consulte 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

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

Cree las imágenes de Docker

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

Descargue la siguiente carpeta del repositorio proxy inverso NGINX: https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/.
Busque el directorio de la app y cree una imagen desde ese directorio:
```
docker build -t web-server-app ./path-to-app-directory
```

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/:


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.

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


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

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

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"
}

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

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

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

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

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$"
   }
],
```

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_.*$"
  ]
},

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

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

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

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

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

Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.
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.
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.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Carga de trabajo Java/JMX de muestra para clústeres de Amazon ECS

Carga de trabajo de muestra de NGINX Plus para clústeres de Amazon ECS