# Instale y configure la recopilación de métricas de Prometheus en clústeres de Amazon ECS
Para recopilar métricas de Prometheus de clústeres de Amazon ECS, se puede utilizar el agente de CloudWatch como recopilador o utilizar el recopilador de AWS Distro para OpenTelemetry. Para obtener información sobre el uso del recopilador AWS Distro para OpenTelemetry, consulte [https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus).
En las siguientes secciones se explica cómo se utiliza el agente de CloudWatch como recopilador para recuperar métricas de Prometheus. Se instala el agente CloudWatch con supervisión de Prometheus en clústeres que ejecutan Amazon ECS y, opcionalmente, se puede configurar el agente para que raspe destinos adicionales. Estas secciones también proporcionan tutoriales opcionales para configurar cargas de trabajo de muestra con el fin de utilizarlas en pruebas con supervisión de Prometheus.
Información de contenedores en Amazon ECS admite las siguientes combinaciones de tipo de lanzamiento y modo de redes para las métricas de Prometheus:
| Tipo de lanzamiento de Amazon ECS | Modos de redes compatibles |
| --- | --- |
| EC2 (Linux) | puente, host y awsvpc |
| Fargate | awsvpc |
**Requisitos del grupo de seguridad de la VPC**
Las reglas de entrada de los grupos de seguridad para las cargas de trabajo de Prometheus deben abrir los puertos de Prometheus al agente de CloudWatch para raspar las métricas de Prometheus por la IP privada.
Las reglas de salida del grupo de seguridad para el agente de CloudWatch deben permitir que el agente de CloudWatch se conecte al puerto de cargas de trabajo de Prometheus mediante la IP privada.
**Topics**
+ [
# Instale el agente CloudWatch con la colección de métricas de Prometheus en clústeres de Amazon ECS
](ContainerInsights-Prometheus-install-ECS.md)
+ [
# Paspado de fuentes adicionales de Prometheus e importación de esas métricas
](ContainerInsights-Prometheus-Setup-configure-ECS.md)
+ [
# (Opcional) Configure de cargas de trabajo en contenedores de Amazon ECS de muestra para realizar pruebas con las métricas de Prometheus
](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)
# Instale el agente CloudWatch con la colección de métricas de Prometheus en clústeres de Amazon ECS
En esta sección se explica cómo se configura el agente de CloudWatch con la supervisión de Prometheus en un clúster que ejecute Amazon ECS. Después de hacerlo, el agente raspa e importa automáticamente métricas para las siguientes cargas de trabajo que se ejecutan en ese clúster.
+ AWS App Mesh
+ Java/JMX
También puede configurar el agente para que recopile e importe métricas de fuentes y cargas de trabajo adicionales de Prometheus.
## Configuración de los roles de IAM
Se necesitan dos roles de IAM para la definición de la tarea del agente de CloudWatch. Si especifica **CreateIAMRoles=True** en la pila de CloudFormation para que Información de contenedores cree estos roles por usted, los roles se crearán con los permisos correctos. Si desea crearlos o usar roles existentes, se requieren los siguientes roles y permisos.
+ **Rol de tarea de ECS del agente de CloudWatch**: el contenedor del agente de CloudWatch utiliza este rol. Debe incluirse la política **CloudWatchAgentServerPolicy** y una política administrada por el cliente que contiene los siguientes permisos que son solo de lectura:
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:ListServices`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeServices`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
+ **Rol de ejecución de tareas de ECS del agente de CloudWatch**: es el rol que Amazon ECS requiere para lanzar y ejecutar los contenedores. Asegúrese de que el rol de ejecución de la tarea tenga adjuntas las políticas **AmazonSSMReadOnlyAccess**, **AmazonECSTaskExecutionRolePolicy**, y .**CloudWatchAgentServerPolicy**. Si desea almacenar más información confidencial para que Amazon ECS la use, consulte [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) (Especificación de información confidencial).
## Instalación del agente de CloudWatch con la supervisión de Prometheus mediante CloudFormation
Se utiliza AWS CloudFormation para instalar el agente CloudWatch con supervisión de Prometheus para clústeres de Amazon ECS. En la siguiente lista, se enumeran los parámetros que utilizará en la plantilla de CloudFormation.
+ **ECSClusterName**: especifica el clúster de Amazon ECS de destino.
+ **CreateIAMRoles**: especifique **True** para crear roles nuevos para el rol de tareas de Amazon ECS y el rol de ejecución de tareas de Amazon ECS. Especifique **False** para reutilizar los roles existentes.
+ **TaskRoleName**: si ha especificado **True** en **CreateIAMRoles**, esto especifica el nombre que debe usarse para el nuevo rol de tareas de Amazon ECS. Si ha especificado **False** en **CreateIAMRoles**, esto especifica el rol existente que se va a utilizar como función de tarea de Amazon ECS.
+ **ExecutionRoleName**: si ha especificado **True** en **CreateIAMRoles**, esto especifica el nombre que debe usarse para el nuevo rol de ejecución de tareas de Amazon ECS. Si ha especificado **False** en **CreateIAMRoles**, esto especifica el rol existente que se va a utilizar como función de ejecución de tareas de Amazon ECS.
+ **ECSNetworkMode**: si utiliza el tipo de lanzamiento EC2, especifique aquí el modo de redes. Debe ser **bridge** o **host**.
+ **ECSLaunchType**: especifique **fargate** o **EC2**.
+ **SecurityGroupID**: si el **ECSNetworkMode** es **awsvpc**, especifique aquí el ID del grupo de seguridad.
+ **SubnetID**: si el **ECSNetworkMode** es **awsvpc**, especifique aquí el ID de la subred.
### Ejemplos de comandos
En esta sección se incluyen ejemplos de comandos de CloudFormation para instalar Información de contenedores con supervisión de Prometheus en varias situaciones.
**Cree una pila de CloudFormation para un clúster de Amazon ECS en modo de red bridge**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=bridge
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Cree una pila de CloudFormation para un clúster de Amazon ECS en modo de red host**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=host
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Cree una pila de CloudFormation para un clúster de Amazon ECS en modo de red awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=EC2
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**Creación de una pila de CloudFormation para un clúster de Fargate en modo de red awsvpc**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=FARGATE
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
### Recursos de AWS que crea la pila de CloudFormation
En la siguiente tabla se enumeran los recursos de AWS que se crean cuando se utiliza CloudFormation para configurar Información de contenedores con supervisión de Prometheus en un clúster de Amazon ECS.
| Tipo de recurso | Nombre del recurso | Comentarios |
| --- | --- | --- |
| AWS::SSM::Parameter | AmazonCloudWatch-CWAgentConfig-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Este es el agente de CloudWatch con la definición predeterminada de formato de métrica integrada de App Mesh y Java/JMX. |
| AWS::SSM::Parameter | AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Esta es la configuración de raspado de Prometheus. |
| AWS::IAM::Role | **\$1ECS\$1TASK\$1ROLE\$1NAME**. | Rol de tarea de Amazon ECS. Esto se crea solo si ha especificado **True** para `CREATE_IAM_ROLES`. |
| AWS::IAM::Role | **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1** | Rol de ejecución de tareas de Amazon ECS. Esto se crea solo si ha especificado **True** para `CREATE_IAM_ROLES`. |
| AWS::ECS::TaskDefinition | cwagent-prometheus-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
| AWS::ECS::Service | cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
### Eliminación de la pila de CloudFormation para el agente de CloudWatch con supervisión de Prometheus
Para eliminar el agente de CloudWatch de un clúster de Amazon ECS, ingrese estos comandos.
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name
aws cloudformation delete-stack \
--stack-name ${CLOUDFORMATION_STACK_NAME} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Paspado de fuentes adicionales de Prometheus e importación de esas métricas
El agente CloudWatch con supervisión de Prometheus necesita dos configuraciones para raspar las métricas de Prometheus. Una de ellas es para las configuraciones estándar de Prometheus que como se documenta en [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) en la documentación de Prometheus. La otra configuración es para la configuración del agente de CloudWatch.
Para los clústeres de Amazon ECS, las configuraciones se integran con Parameter Store de AWS Systems Manager según los secretos de la definición de tareas de Amazon ECS:
+ El secreto `PROMETHEUS_CONFIG_CONTENT` es para la configuración de raspado de Prometheus.
+ El secreto `CW_CONFIG_CONTENT` es para la configuración del agente de CloudWatch.
Para raspar las fuentes adicionales de las métricas de Prometheus e importarlas a CloudWatch, debe modificar tanto la configuración de raspado de Prometheus como la configuración del agente de CloudWatch y, a continuación, debe volver a implementar el agente con la configuración actualizada.
**Requisitos del grupo de seguridad de la VPC**
Las reglas de entrada de los grupos de seguridad para las cargas de trabajo de Prometheus deben abrir los puertos de Prometheus al agente de CloudWatch para raspar las métricas de Prometheus por la IP privada.
Las reglas de salida del grupo de seguridad para el agente de CloudWatch deben permitir que el agente de CloudWatch se conecte al puerto de cargas de trabajo de Prometheus mediante la IP privada.
## Configuración de raspado de Prometheus
El agente de CloudWatch es compatible con la configuración de raspado estándar de Prometheus como se describe en [ ](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) en la documentación de Prometheus. Se puede editar esta sección para actualizar las configuraciones que ya están en este archivo y agregar destinos adicionales de raspado de Prometheus. De forma predeterminada, el archivo de configuración de muestra contiene las siguientes líneas de configuración global:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval**: define la frecuencia con la que se deben raspar los destinos.
+ **scrape\$1timeout**: define cuánto tiempo debe esperar antes de que se agote el tiempo de espera de una petición de raspado.
También puede definir valores diferentes para estos parámetros en el nivel de trabajo, para anular las configuraciones globales.
### Trabajos de raspado de Prometheus
Los archivos YAML del agente de CloudWatch ya tienen algunos trabajos de raspado configurados de forma predeterminada. Por ejemplo, en los archivos YAML para Amazon ECS, como `cwagent-ecs-prometheus-metric-for-bridge-host.yaml`, los trabajos de raspado predeterminados se configuran en la sección `ecs_service_discovery`.
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
},
"task_definition_list": [
{
"sd_job_name": "ecs-appmesh-colors",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+",
"sd_metrics_path": "/stats/prometheus"
},
{
"sd_job_name": "ecs-appmesh-gateway",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+",
"sd_metrics_path": "/stats/prometheus"
}
]
}
```
Cada uno de estos destinos predeterminados se raspan y las métricas se envían a CloudWatch en eventos de registro mediante un formato de métrica integrada. Para obtener más información, consulte [Incrustar métricas en los registros](CloudWatch_Embedded_Metric_Format.md).
Los eventos de registro de los clústeres de Amazon ECS se almacenan en el grupo de registros **/aws/ecs/containerinsights/*cluster\$1name*/prometheus**.
Cada trabajo de extracción está contenido en un flujo de registros diferente en este grupo de registros.
Para agregar un nuevo destino de raspado, se debe agregar una entrada nueva en la sección `task_definition_list` en la sección `ecs_service_discovery` del archivo YAML y reiniciar el agente. Para obtener un ejemplo de este proceso, consulte [Tutorial para agregar un destino de raspado nuevo de Prometheus: métricas del servidor de la API de Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).
## Configuración del agente de CloudWatch para Prometheus
El archivo de configuración del agente de CloudWatch cuenta con una sección `prometheus` en `metrics_collected` para la configuración de raspado de Prometheus. Incluye las siguientes opciones de configuración:
+ **nombre\$1clúster**: especifica el nombre del clúster que se va a agregar como etiqueta en el evento de registro. Este campo es opcional. Si lo omite, el agente puede detectar el nombre del clúster de Amazon ECS.
+ **log\$1group\$1name**: especifica el nombre del grupo de registros para las métricas de Prometheus raspadas. Este campo es opcional. Si lo omite, CloudWatch usa **/aws/ecs/containerinsights/*cluster\$1name*/prometheus** para los registros de clústeres de Amazon ECS.
+ **prometheus\$1config\$1path**: especifica la ruta del archivo de configuración de raspado de Prometheus. Si el valor de este campo comienza con `env:`, el contenido del archivo de configuración de raspado de Prometheus se recuperará de la variable de entorno del contenedor. No cambie este campo.
+ **ecs\$1service\$1discovery**: es la sección para especificar las configuraciones de las funciones de detección automática de destino de Prometheus de Amazon ECS . Se admiten dos modos para detectar los destinos de Prometheus: detección basada en la etiqueta de docker del contenedor o detección basada en la expresión regular ARN de definición de tarea de Amazon ECS. Puede utilizar los dos modos juntos y el agente de CloudWatch desduplicará los destinos detectados en función de: *\$1private\$1ip\$1:\$1port\$1/\$1metrics\$1path\$1*.
La sección `ecs_service_discovery` puede incluir los siguientes campos:
+ `sd_frequency` es la frecuencia para detectar a los exportadores de Prometheus. Especifique un número y un sufijo de unidad. Por ejemplo, `1m` para una vez por minuto o `30s` para una vez cada 30 segundos. Los sufijos de unidad válidos son `ns`, `us`, `ms`, `s`, `m` y `h`.
Este campo es opcional. El valor predeterminado es 60 segundos (1 minuto).
+ `sd_target_cluster` es el nombre de clúster de Amazon ECS de destino para la detección automática. Este campo es opcional. El valor predeterminado es el nombre del clúster de Amazon ECS donde está instalado el agente de CloudWatch.
+ `sd_cluster_region` es la Región del clúster de Amazon ECS de destino. Este campo es opcional. El valor predeterminado es la Región del clúster de Amazon ECS donde está instalado el agente de CloudWatch.
+ `sd_result_file` es la ruta del archivo YAML para los resultados de destino de Prometheus. La configuración de raspado de Prometheus hará referencia a este archivo.
+ `docker_label` es una sección opcional que se puede utilizar para especificar la configuración para la detección de servicios basada en etiquetas docker. Si omite esta sección, no se utiliza la detección basada en etiquetas docker. Esta sección puede incluir los siguientes campos:
+ `sd_port_label` es el nombre de etiqueta docker del contenedor que especifica el puerto del contenedor para las métricas de Prometheus. El valor predeterminado es `ECS_PROMETHEUS_EXPORTER_PORT`. Si el contenedor no tiene esta etiqueta docker, el agente de CloudWatch lo omitirá.
+ `sd_metrics_path_label` es el nombre de etiqueta docker del contenedor que especifica la ruta de métricas de Prometheus. El valor predeterminado es `ECS_PROMETHEUS_METRICS_PATH`. Si el contenedor no tiene esta etiqueta docker, el agente asume la ruta predeterminada `/metrics`.
+ `sd_job_name_label` es el nombre de etiqueta docker del contenedor que especifica el nombre del trabajo de raspado de Prometheus. El valor predeterminado es `job`. Si el contenedor no tiene esta etiqueta docker, el agente de CloudWatch utiliza el nombre del trabajo en la configuración de raspado de Prometheus.
+ `task_definition_list` es una sección opcional que se puede utilizar para especificar la configuración de la detección de servicios basada en definiciones de tareas. Si omite esta sección, no se utiliza la detección basada en definiciones de tareas. Esta sección puede incluir los siguientes campos:
+ `sd_task_definition_arn_pattern` es el patrón que se utiliza para especificar las definiciones de tareas de Amazon ECS que se van a detectar. Esta es una expresión regular.
+ `sd_metrics_ports` enumera el containerPort para las métricas de Prometheus. Separe los containerPorts con punto y coma.
+ `sd_container_name_pattern` especifica los nombres de contenedor de tareas de Amazon ECS. Esta es una expresión regular.
+ `sd_metrics_path` especifica la ruta de la métrica de Prometheus. Si omite esto, el agente asume la ruta de acceso predeterminada de las `/metrics`
+ `sd_job_name` especifica el nombre del trabajo de raspado de Prometheus. Si omite este campo, el agente de CloudWatch utilizará el nombre de trabajo en la configuración de borrado de Prometheus.
+ `service_name_list_for_tasks` es una sección opcional que puede utilizar para especificar la configuración de la detección basada en nombres de servicio. Si omite esta sección, no se utiliza la detección basada en nombres de servicio. Esta sección puede incluir los siguientes campos:
+ `sd_service_name_pattern` es el patrón que se debe utilizar para especificar el servicio Amazon ECS en el que se van a detectar las tareas. Esta es una expresión regular.
+ `sd_metrics_ports` enumera el `containerPort` para ver las métricas de Prometheus. Separe varios `containerPorts` con punto y coma.
+ `sd_container_name_pattern` especifica los nombres de contenedor de tareas de Amazon ECS. Esta es una expresión regular.
+ `sd_metrics_path` especifica la ruta de las métricas de Prometheus. Si omite esto, el agente asume la ruta de acceso predeterminada `/metrics`.
+ `sd_job_name` especifica el nombre del trabajo de raspado de Prometheus. Si omite este campo, el agente de CloudWatch utilizará el nombre de trabajo en la configuración de raspado de Prometheus.
+ **metric\$1declaration**: son secciones que especifican la matriz de registros con formato de métrica integrada que se van a generar. Hay secciones `metric_declaration` para cada fuente de Prometheus desde las que el agente de CloudWatch importa de forma predeterminada. Cada una de estas secciones incluye los siguientes campos:
+ `label_matcher` es una expresión regular que verifica el valor de las etiquetas que aparecen en `source_labels`. Las métricas que concuerdan se pueden incorporar al formato de métrica integrada que se envía a CloudWatch.
Si tiene varias etiquetas especificadas en `source_labels`, se recomienda que evite el uso de los caracteres `^` o `$` en la expresión regular para `label_matcher`.
+ `source_labels` especifica el valor de las etiquetas que se comprueban con `label_matcher`.
+ `label_separator` especifica el separador que se utilizará en la línea ` label_matcher` si se especifican múltiples `source_labels`. El valor predeterminado es `;`. Puede ver este valor predeterminado utilizado en la línea `label_matcher` en el siguiente ejemplo.
+ `metric_selectors` es una expresión regular que especifica las métricas que se van a recopilar y enviar a CloudWatch.
+ `dimensions` es la lista de etiquetas que se van a utilizar como dimensiones de CloudWatch en cada métrica seleccionada.
Consulte el siguiente ejemplo, `metric_declaration`.
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system$",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
En este ejemplo se configura una sección de formato de métricas integradas para que se envíe como evento de registro si se cumplen las condiciones siguientes:
+ El valor de `Service` contiene `node-exporter` o `kube-dns`.
+ El valor de `Namespace` es `kube-system`.
+ La métrica de Prometheus `coredns_dns_request_type_count_total` contiene ambas etiquetas, `Service` y `Namespace`.
El evento de registro que se envía incluye la siguiente sección resaltada:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
# Guía detallada para la detección automática en clústeres de Amazon ECS
Prometheus proporciona docenas de mecanismos dinámicos de detección de servicios, como se describe en [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config). Sin embargo, no existe una detección de servicios integrado para Amazon ECS. El agente CloudWatch agrega este mecanismo.
Cuando se habilita la detección de servicios de Amazon ECS Prometheus, el agente de CloudWatch realiza periódicamente las siguientes llamadas a la API a Amazon ECS y a los frontends de Amazon EC2 para recuperar los metadatos de las tareas ECS en ejecución en el clúster de ECS de destino.
```
EC2:DescribeInstances
ECS:ListTasks
ECS:ListServices
ECS:DescribeContainerInstances
ECS:DescribeServices
ECS:DescribeTasks
ECS:DescribeTaskDefinition
```
El agente de CloudWatch utiliza los metadatos para examinar los destinos de Prometheus dentro del clúster de ECS. El agente de CloudWatch admite tres modos de detección de servicio:
+ Detección de servicio basada en etiquetas docker de contenedor
+ Detección de servicio basada en expresiones regulares ARN de definición de tarea de ECS
+ Detección de servicio basada en expresiones regulares de nombre de servicio de ECS
Todos los modos se pueden utilizar de forma conjunta. El agente de CloudWatch desduplica los destinos detectados en función de: `{private_ip}:{port}/{metrics_path}`.
Todos los destinos detectados se registran en un archivo de resultados que el campo de configuración `sd_result_file` especifica dentro del contenedor del agente de CloudWatch. A continuación se muestra un archivo de resultados de ejemplo.
```
- targets:
- 10.6.1.95:32785
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT: "9406"
ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port
TaskGroup: family:demo-jar-ec2-bridge-dynamic-port
TaskRevision: "7"
VpcId: vpc-01234567890
container_name: demo-jar-ec2-bridge-dynamic-port
job: demo-jar-ec2-bridge-dynamic
- targets:
- 10.6.3.193:9404
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404"
ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port
TaskGroup: family:demo-jar-tomcat-bridge-mapped-port
TaskRevision: "12"
VpcId: vpc-01234567890
container_name: demo-tomcat-ec2-bridge-mapped-port
job: demo-tomcat-ec2-bridge-mapped-port
```
Puede integrar directamente este archivo de resultados con la detección de servicios basada en archivos de Prometheus. Para obtener más información acerca de la detección de servicios basada en archivos de Prometheus, consulte [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config).
Suponga que el archivo de resultados se registra en `/tmp/cwagent_ecs_auto_sd.yaml`, la siguiente configuración de raspado de Prometheus lo consumirá.
```
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: cwagent-ecs-file-sd-config
sample_limit: 10000
file_sd_configs:
- files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ]
```
El agente de CloudWatch también agrega las siguientes etiquetas adicionales para los destinos detectados.
+ `container_name`
+ `TaskDefinitionFamily`
+ `TaskRevision`
+ `TaskGroup`
+ `StartedBy`
+ `LaunchType`
+ `job`
+ `__metrics_path__`
+ Etiquetas docker
Cuando el clúster tiene el tipo de lanzamiento EC2, se agregan las tres etiquetas siguientes.
+ `InstanceType`
+ `VpcId`
+ `SubnetId`
**nota**
Las etiquetas docker que no concuerdan con la expresión regular `[a-zA-Z_][a-zA-Z0-9_]*` se filtran. Coincide con las convenciones de Prometheus enumeradas en `label_name` en [Configuration file](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) (Archivo de configuración) en la documentación de Prometheus.
## Ejemplos de configuración de detección de servicios de ECS
En esta sección se incluyen ejemplos que demuestran la detección de servicios de ECS.
**Ejemplo 1**
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
}
}
```
En este ejemplo se habilita la detección de servicios basada en etiquetas docker El agente de CloudWatch consultará los metadatos de las tareas de ECS una vez por minuto y registrará los destinos detectados en el archivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro del contenedor del agente de CloudWatch.
El valor predeterminado de `sd_port_label` en la sección `docker_label` es `ECS_PROMETHEUS_EXPORTER_PORT`. Si algún contenedor en ejecución en las tareas de ECS tiene una etiqueta docker `ECS_PROMETHEUS_EXPORTER_PORT`, el agente CloudWatch utiliza el valor como `container port` para examinar todos los puertos expuestos del contenedor. Si hay una concordancia, el puerto del host mapeado más la IP privada del contenedor se utilizan para construir el destino del exportador de Prometheus en el siguiente formato: `private_ip:host_port`.
El valor predeterminado de `sd_metrics_path_label` en la sección `docker_label` es `ECS_PROMETHEUS_METRICS_PATH`. Si el contenedor tiene esta etiqueta docker, el valor se utilizará como la `__metrics_path__` . Si el contenedor no tiene esta etiqueta, se utiliza el valor predeterminado `/metrics`.
El valor predeterminado de `sd_job_name_label` en la sección `docker_label` es `job`. Si el contenedor tiene esta etiqueta docker, el valor se agregará como una de las etiquetas para que el destino reemplace el nombre de trabajo predeterminado que se especifica en la configuración de Prometheus. El valor de esta etiqueta docker se utiliza como nombre de flujo de registro en el grupo de registros de CloudWatch Logs.
**Ejemplo 2**
```
"ecs_service_discovery": {
"sd_frequency": "15s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A",
"sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME"
}
}
```
En este ejemplo se habilita la detección de servicios basada en etiquetas docker. El agente de CloudWatch consultará los metadatos de las tareas de ECS cada 15 segundos y registrará los destinos detectados en el archivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro del contenedor del agente de CloudWatch. Los contenedores con una etiqueta docker de `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` se examinarán. El valor de la etiqueta docker `ECS_PROMETHEUS_JOB_NAME` se utiliza como el nombre del trabajo.
**Ejemplo 3**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"task_definition_list": [
{
"sd_job_name": "java-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9404; 9406",
"sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+"
},
{
"sd_job_name": "envoy-prometheus",
"sd_metrics_path": "/stats/prometheus",
"sd_container_name_pattern": "^envoy$",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23"
}
]
}
```
Este ejemplo habilita la detección de servicios basada en expresiones ARN regulares de definición de tareas de ECS. El agente de CloudWatch consultará los metadatos de las tareas de ECS cada cinco minutos y registrará los destinos detectados en el archivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro del contenedor del agente de CloudWatch.
Se definen dos secciones de expresión regular de ARN de definición de tarea:
+ Para la primera sección, las tareas de ECS con `javajmx` en la definición de tarea de ECS de ARN se filtran para el análisis del puerto del contenedor. Si los contenedores dentro de estas tareas de ECS exponen el puerto del contenedor en 9404 o 9406, el puerto del host mapeado junto con la IP privada del contenedor se utilizan para crear los destinos del exportador de Prometheus. El valor de `sd_metrics_path` establece `__metrics_path__` a `/metrics`. Por lo tanto, el agente de CloudWatch raspará las métricas de Prometheus de `private_ip:host_port/metrics` y las métricas raspadas se enviarán al flujo de registro `java-prometheus` en CloudWatch Logs en el grupo de registros `/aws/ecs/containerinsights/cluster_name/prometheus`.
+ Para la segunda sección, las tareas de ECS con `appmesh` en los ARN de definición de tareas de ECS y con `version` de `:23` se filtran para el análisis del puerto del contenedor. Para contenedores con un nombre de `envoy` que exponen el puerto del contenedor en `9901`, el puerto del host mapeado junto con la IP privada del contenedor se utilizan para crear los destinos del exportador de Prometheus. El valor dentro de estas tareas de ECS expone el puerto contenedor en 9404 o 9406, el puerto del host mapeado junto con la IP privada del contenedor se utilizan para crear los destinos del exportador de Prometheus. El valor de `sd_metrics_path` establece `__metrics_path__` a `/stats/prometheus`. Por lo tanto, el agente de CloudWatch eliminará las métricas de Prometheus de `private_ip:host_port/stats/prometheus` y enviará las métricas raspadas al flujo de registros `envoy-prometheus` en CloudWatch Logs en el grupo de registros `/aws/ecs/containerinsights/cluster_name/prometheus`.
**Ejemplo 4**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-.*"
},
{
"sd_job_name": "haproxy-prometheus",
"sd_metrics_path": "/stats/metrics",
"sd_container_name_pattern": "^haproxy$",
"sd_metrics_ports": "8404",
"sd_service_name_pattern": ".*haproxy-service.*"
}
]
}
```
En este ejemplo se habilita la detección de servicios basada en expresiones regulares del nombre de servicio de ECS. El agente de CloudWatch consultará los metadatos de los servicios de ECS cada cinco minutos y registrará los destinos detectados en el archivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro del contenedor del agente de CloudWatch.
Se definen dos secciones de expresiones regulares de nombre de servicio:
+ Para la primera sección, las tareas de ECS asociadas con los servicios de ECS que tienen nombres que concuerdan con la expresión regular `^nginx-.*` se filtran para el análisis del puerto del contenedor. Si los contenedores dentro de estas tareas de ECS exponen el puerto del contenedor en 9113, el puerto del host mapeado junto con la IP privada del contenedor se utilizan para crear los destinos del exportador de Prometheus. El valor de `sd_metrics_path` establece `__metrics_path__` a `/metrics`. Por lo tanto, el agente de CloudWatch raspará las métricas de Prometheus de `private_ip:host_port/metrics`, y las métricas raspadas se enviarán al flujo de registro `nginx-prometheus` en CloudWatch Logs en el grupo de registros `/aws/ecs/containerinsights/cluster_name/prometheus`.
+ Para la segunda sección, las tareas de ECS asociadas con los servicios de ECS que tienen nombres que concuerdan con la expresión regular `.*haproxy-service.*` se filtran para el análisis del puerto del contenedor. En contenedores con un nombre de `haproxy` que exponen el puerto del contenedor en 8404, el puerto del host mapeado junto con la IP privada del contenedor se utilizan para crear los destinos del exportador de Prometheus. El valor de `sd_metrics_path` establece `__metrics_path__` a `/stats/metrics`. Por lo tanto, el agente de CloudWatch raspará las métricas de Prometheus de `private_ip:host_port/stats/metrics`, y las métricas de raspado se enviarán al flujo de registro `haproxy-prometheus` en CloudWatch Logs en el grupo de registros `/aws/ecs/containerinsights/cluster_name/prometheus`.
**Ejemplo 5**
```
"ecs_service_discovery": {
"sd_frequency": "1m30s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL",
"sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL",
"sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL"
}
"task_definition_list": [
{
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": "*memcached.*"
}
]
}
```
En este ejemplo se habilitan los dos modos de detección de servicios de ECS. El agente de CloudWatch consultará los metadatos de las tareas de ECS cada 90 segundos y registrará los destinos detectados en el archivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro del contenedor del agente de CloudWatch.
Para la configuración de detección de servicios basada en docker:
+ Las tareas de ECS con etiqueta docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` se filtrarán para el análisis del puerto de Prometheus. El puerto de destino del contenedor de Prometheus se especifica por el valor de la etiqueta `MY_PROMETHEUS_EXPORTER_PORT_LABEL`.
+ El valor de la etiqueta docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` se utiliza para `__metrics_path__`. Si el contenedor no tiene esta etiqueta docker, se utiliza el valor predeterminado `/metrics`.
+ El valor de la etiqueta docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` se utiliza como etiqueta de trabajo. Si el contenedor no tiene esta etiqueta docker, se utiliza el nombre del trabajo definido en la configuración de Prometheus.
Para la configuración de la detección de servicio basada en expresiones regulares ARN de definición de tareas de ECS:
+ Las tareas de ECS con `memcached` en los ARN de definición de tareas de ECS se filtran para el análisis del puerto del contenedor. El puerto del contenedor del destino de Prometheus es 9150 de acuerdo a la definición de `sd_metrics_ports`. Se utiliza la ruta de métricas predeterminada `/metrics`. Se utiliza el nombre del trabajo definido en la configuración de Prometheus.
# (Opcional) Configure de cargas de trabajo en contenedores de Amazon ECS de muestra para realizar pruebas con las métricas de Prometheus
Para probar la compatibilidad de las métricas de Prometheus en Información de contenedores de CloudWatch, puede configurar una o varias de las siguientes cargas de trabajo en contenedores. El agente de CloudWatch compatible con Prometheus recopila automáticamente las métricas de cada una de estas cargas de trabajo. Para ver las métricas que se recopilan de forma predeterminada, consulte [Métricas de Prometheus que el agente de CloudWatch recopila](ContainerInsights-Prometheus-metrics.md).
**Topics**
+ [
# Carga de trabajo de App Mesh de muestra para clústeres de Amazon ECS
](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md)
+ [
# Carga de trabajo Java/JMX de muestra para clústeres de Amazon ECS
](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md)
+ [
# Carga de trabajo NGINX de muestra para clústeres de Amazon ECS
](ContainerInsights-Prometheus-Setup-nginx-ecs.md)
+ [
# Carga de trabajo de muestra de NGINX Plus para clústeres de Amazon ECS
](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md)
+ [
# Tutorial para añadir un nuevo destino de raspado de Prometheus: Memcached en Amazon ECS
](ContainerInsights-Prometheus-Setup-memcached-ecs.md)
+ [
# Tutorial para el raspado de métricas de Redis OSS Prometheus en Amazon ECS Fargate
](ContainerInsights-Prometheus-Setup-redis-ecs.md)
# Carga de trabajo de App Mesh de muestra para clústeres de Amazon ECS
Para recopilar métricas de una carga de trabajo de muestra de Prometheus para Amazon ECS, se debe ejecutar Información de contenedores en el clúster. Para obtener más información sobre la instalación de Información de contenedores, consulte [Configuración de Información de contenedores en Amazon ECS](deploy-container-insights-ECS.md).
En primer lugar, siga esta [walkthrough](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs) (explicación) para implementar la aplicación de color de muestra en el clúster de Amazon ECS. Una vez finalizado, tendrá las métricas de Prometheus de App Mesh expuestas en el puerto 9901.
A continuación, siga estos pasos para instalar el agente de CloudWatch con supervisión de Prometheus en el mismo clúster de Amazon ECS en el que instaló la aplicación de color. Los pasos descritos en esta sección instalan el agente de CloudWatch en modo de redes puente.
Las variables de entorno `ENVIRONMENT_NAME`, `AWS_PROFILE` y `AWS_DEFAULT_REGION` que establezca en la explicación también se utilizarán en los siguientes pasos.
**Para instalar el agente de CloudWatch con supervisión de Prometheus para las pruebas**
1. Descargue la plantilla de CloudFormation 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. Configure el modo de red con los siguientes comandos.
```
export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME}
export ECS_NETWORK_MODE=bridge
```
1. Cree la pila de CloudFormation con los siguientes comandos.
```
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. (Opcional) Cuando se crea la pila de CloudFormation, se observa un mensaje de `CREATE_COMPLETE`. Si desea verificar el estado antes de ver el mensaje, ingrese el siguiente 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}
```
**Solución de problemas**
En los pasos de la explicación se utiliza jq para analizar el resultado de salida de AWS CLI. Para obtener más información sobre la instalación de jq, consulte [jq](https://stedolan.github.io/jq/). Utilice el siguiente comando para establecer el formato de salida predeterminado de AWS CLI a formato JSON para que jq pueda analizarlo de forma correcta.
```
$ aws configure
```
Cuando la respuesta llegue a `Default output format`, ingrese **json**.
## Desinstale el agente de CloudWatch con supervisión de Prometheus
Cuando termine de realizar la prueba, ingrese el siguiente comando para desinstalar el agente de CloudWatch mediante la eliminación de la pila de CloudFormation.
```
aws cloudformation delete-stack \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Carga de trabajo Java/JMX de muestra para clústeres de Amazon ECS
JMX Exporter es un exportador oficial de Prometheus que puede extraer y exponer mBeans de JMX como métricas de Prometheus. Para obtener más información, consulte [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
El agente de CloudWatch compatible con Prometheus raspa las métricas de Java/JMX Prometheus en función de la configuración de detección de servicios en el clúster de Amazon ECS. Puede configurar JMX Exporter para exponer las métricas en un puerto o ruta (metrics\$1path) diferente. Si cambia el puerto o la ruta, actualice la sección `ecs_service_discovery` predeterminada en la configuración del agente de CloudWatch.
Para recopilar métricas de una carga de trabajo de Prometheus de muestra para Amazon ECS, debe ejecutar Información de contenedores en el clúster. Para obtener más información sobre la instalación de Información de contenedores, consulte [Configuración de Información de contenedores en Amazon ECS](deploy-container-insights-ECS.md).
**Para instalar la carga de trabajo de ejemplo de Java/JMX para clústeres de Amazon ECS**
1. Siga los pasos descritos en estas secciones para crear las imágenes de Docker.
+ [Ejemplo: Imagen de Docker de una aplicación Jar de Java con métricas de Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar)
+ [Ejemplo: Imagen de Apache Tomcat Docker con métricas de Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat)
1. Especifique las dos etiquetas docker siguientes en el archivo de definición de tareas de Amazon ECS. A continuación, se puede ejecutar la definición de tarea como un Servicio ECS de Amazon o como una tarea de Amazon ECS en el clúster.
+ Establezca `ECS_PROMETHEUS_EXPORTER_PORT` para apuntar al ContainerPort donde están expuestas las métricas de Prometheus.
+ Establece `Java_EMF_Metrics` en `true`. El agente de CloudWatch utiliza este indicador para generar el formato de métrica integrada en el evento de registro.
A continuación, se muestra un ejemplo:
```
{
"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"
}
```
La configuración predeterminada del agente de CloudWatch en la plantilla de CloudFormation permite tanto la detección de servicios basados en etiquetas docker como la detección de servicios basada en ARN de definición de tareas. Para ver estas configuraciones predeterminadas, consulte la línea 65 del [CloudWatch agent YAML configuration file](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) (Archivo de configuración YAML del agente de CloudWatch). Los contenedores con etiquetas `ECS_PROMETHEUS_EXPORTER_PORT` se detectarán automáticamente en función del puerto de contenedor especificado para el raspado de Prometheus.
La configuración predeterminada del agente de CloudWatch también tiene la configuración `metric_declaration` para Java/JMX en la línea 112 del mismo archivo. Todas las etiquetas docker de los contenedores de destino se agregarán como etiquetas adicionales en las métricas de Prometheus y se enviarán a CloudWatch Logs. Para los contenedores Java/JMX con etiqueta docker `Java_EMF_Metrics=“true”`, se generará el formato de métrica integrada.
# 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](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
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**
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 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
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
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\$1cluster\$1name*/prometheus**, en el flujo de registros *nginx-prometheus-exporter*.
# Carga de trabajo de muestra de NGINX Plus para clústeres de Amazon ECS
NGINX Plus es la versión comercial de NGINX. Debe contar con una licencia para utilizarla. Para obtener más información, consulte [NGINX Plus](https://www.nginx.com/products/nginx/).
El exportador NGINX de Prometheus puede raspar y exponer datos de NGINX como las métricas de Prometheus. En este ejemplo se utiliza el exportador junto con el servicio proxy inverso NGINX Plus 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 realiza el raspado de las métricas de NGINX Plus Prometheus basado 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 de `ecs_service_discovery` en el archivo de configuración del agente de CloudWatch.
## Instale la carga de trabajo de muestra del proxy inverso NGINX Plus 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 Plus**
1. Descargue la siguiente carpeta del repositorio del 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 Plus. Antes de poder crear la imagen para NGINX Plus, debe obtener la clave llamada `nginx-repo.key` y el certificado SSL `nginx-repo.crt` para la licencia de NGINX Plus. Cree un directorio y almacene en él la `nginx-repo.key` y los archivos `nginx-repo.crt`.
En el directorio que acaba de crear, cree los siguientes dos archivos:
+ Una muestra de Dockerfile con el siguiente contenido. Este archivo docker se adopta a partir de un archivo de muestra que se proporciona en [https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/\$1docker\$1plus\$1image](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image). El cambio importante que se realiza es que se carga un archivo por separado, llamado`nginx.conf`, que se creará en el siguiente paso.
```
FROM debian:buster-slim
LABEL maintainer="NGINX Docker Maintainers “
# Define NGINX versions for NGINX Plus and NGINX Plus modules
# Uncomment this block and the versioned nginxPackages block in the main RUN
# instruction to install a specific release
# ENV NGINX_VERSION 21
# ENV NJS_VERSION 0.3.9
# ENV PKG_RELEASE 1~buster
# Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/))
# and copy to the build context
COPY nginx-repo.crt /etc/ssl/nginx/
COPY nginx-repo.key /etc/ssl/nginx/
# COPY nginx.conf /etc/ssl/nginx/nginx.conf
RUN set -x \
# Create nginx user/group first, to be consistent throughout Docker variants
&& addgroup --system --gid 101 nginx \
&& adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \
&& \
NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \
found=''; \
for server in \
ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \
hkp://keyserver.ubuntu.com:80 \
hkp://p80.pool.sks-keyservers.net:80 \
pgp.mit.edu (http://pgp.mit.edu/) \
; do \
echo "Fetching GPG key $NGINX_GPGKEY from $server"; \
apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \
done; \
test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \
apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \
# Install the latest release of NGINX Plus and/or NGINX Plus modules
# Uncomment individual modules if necessary
# Use versioned packages over defaults to specify a release
&& nginxPackages=" \
nginx-plus \
# nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-xslt \
# nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-geoip \
# nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-image-filter \
# nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-perl \
# nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-njs \
# nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \
" \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \
&& printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
$nginxPackages \
gettext-base \
curl \
&& apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \
&& rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx
# Forward request logs to Docker log collector
RUN ln -sf /dev/stdout /var/log/nginx/access.log \
&& ln -sf /dev/stderr /var/log/nginx/error.log
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
STOPSIGNAL SIGTERM
CMD ["nginx", "-g", "daemon off;"]
```
+ Un archivo `nginx.conf`, modificado desde [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. Cree una imagen a partir de los archivos en el directorio nuevo:
```
docker build -t nginx-plus-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 Plus 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 Plus 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 JSON de definición de tarea con el siguiente contenido. Reemplace *your-customized-nginx-plus-image* por el URI de imagen para la imagen personalizada de NGINX Plus, y reemplace *your-web-server-app-image* por el URI de imagen para la imagen de la aplicación del servidor 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. Registre 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 con el siguiente comando:
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-plus-service \
--task-definition nginx-plus-sample-stack:1 \
--desired-count 1
```
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-plus-service$`. En la siguiente sección se proporcionan más detalles.
### Configure el agente de CloudWatch para que raspe las métricas de NGINX Plus de 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**
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-plus-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-plus.*"
}
],
```
1. En el mismo archivo, agregue la siguiente sección en la sección `metric_declaration` para permitir las métricas de NGINX Plus. Asegúrese de seguir el patrón de sangría existente.
```
{
"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. 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-plus-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-plus-scraping-support**. Se debería ver un cambio aplicado al recurso **CWAgentConfigSSMParamete**. Ejecute el conjunto de cambios y reinicie la tarea del agente de CloudWatch al ingresar 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 Plus
Ahora se pueden visualizar las métricas de NGINX Plus 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 están en el grupo de registro **/aws/containerinsights/*your\$1cluster\$1name*/prometheus**, en el flujo de registros *nginx-plus-prometheus-exporter*.
# Tutorial para añadir un nuevo destino de raspado de Prometheus: Memcached en Amazon ECS
Este tutorial proporciona una introducción práctica para raspar las métricas de Prometheus de una aplicación Memcached de muestra en un clúster de Amazon ECS con el tipo de lanzamiento de EC2. El agente CloudWatch detectará automáticamente el destino del exportador de Memcached de Prometheus mediante la detección de servicios basada en la definición de tareas de ECS.
Memcached es un sistema de almacenamiento en caché en memoria distribuida de uso general. A menudo se utiliza para acelerar los sitios web dirigidos por base de datos dinámicos mediante el almacenamiento en caché de datos y objetos en la RAM para reducir el número de veces que se debe leer una fuente de datos externa (como una base de datos o una API). Para obtener más información, consulte [What is Memcached?](https://www.memcached.org/) (¿Qué es Memcached?)
[memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (Apache Licencia 2.0) es uno de los exportadores oficiales de Prometheus. De forma predeterminada, memcache\$1exporter sirve en el puerto 0.0.0.0:9150 en `/metrics.`
En este tutorial se utilizan las imágenes de Docker en los siguientes dos repositorios de Docker Hub:
+ [ Memcached](https://hub.docker.com/_/memcached?tab=description)
+ [ prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/)
**Requisito previo**
Para recopilar métricas de una carga de trabajo de muestra de Prometheus para Amazon ECS, se debe ejecutar Información de contenedores en el clúster. Para obtener más información sobre la instalación de Información de contenedores, consulte [Configuración de Información de contenedores en Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [
## Establezca las variables de entorno del clúster de EC2 de Amazon ECS
](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment)
+ [
## Instale la carga de trabajo de muestra de Memcached
](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload)
+ [
## Configure el agente de CloudWatch para que realice el raspado de las métricas de Memcached Prometheus
](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent)
+ [
## Visualización de las métricas de Memcached
](#ContainerInsights-Prometheus-ECS-memcached-view)
## Establezca las variables de entorno del clúster de EC2 de Amazon ECS
**Para establecer las variables de entorno del clúster de EC2 de Amazon ECS**
1. Instale la CLI de Amazon ECS si aún no lo ha hecho. Para obtener más información, consulte [Installing the Amazon ECS CLI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html) (Instalación de la CLI de Amazon ECS).
1. Establezca el nuevo nombre del clúster de Amazon ECS y la Región. Por ejemplo:
```
ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Opcional) Si aún no cuenta con un clúster de Amazon ECS con el tipo de lanzamiento de EC2 en el que desea instalar la carga de trabajo de muestra de Memcached y el agente de CloudWatch de ejemplo, puede crear uno con el siguiente comando.
```
ecs-cli up --capability-iam --size 1 \
--instance-type t3.medium \
--cluster $ECS_CLUSTER_NAME \
--region $AWS_REGION
```
El resultado esperado de este comando es el siguiente:
```
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.
```
## Instale la carga de trabajo de muestra de Memcached
**Para instalar la carga de trabajo de muestra de Memcached que expone las métricas de Prometheus**
1. Descargue la plantilla de CloudFormation de Memcached 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/sample_traffic/memcached/memcached-traffic-sample.yaml
```
1. Establezca los nombres de rol de IAM que se crearán para Memcached con los siguientes comandos.
```
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. Instale la carga de trabajo de muestra de Memcached mediante el siguiente comando. Este ejemplo instala la carga de trabajo en el modo de red `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
```
La pila de CloudFormation crea cuatro recursos:
+ Un rol de tarea de ECS
+ Un rol de ejecución de tareas de ECS
+ Una definición de tarea de Memcached
+ Un servicio de Memcached
En la definición de tarea de Memcached, se definen dos contenedores:
+ El contenedor principal ejecuta una aplicación de Memcached simple y abre el puerto 11 211 para el acceso.
+ El otro contenedor ejecuta el proceso exportador de Redis OSS para exponer las métricas de Prometheus en el puerto 9150. Este es el contenedor que el agente de CloudWatch detectará y raspará.
## Configure el agente de CloudWatch para que realice el raspado de las métricas de Memcached Prometheus
**Para configurar el agente de CloudWatch para que raspe las métricas de Memcached Prometheus**
1. Descargue la última versión de `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` mediante 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-awsvpc.yaml
```
1. Abra el archivo con un editor de texto y busque la configuración completa del agente de CloudWatch detrás de la clave de `value` en la sección `resource:CWAgentConfigSSMParameter`.
A continuación, en la sección `ecs_service_discovery`, agregue la siguiente configuración en la sección `task_definition_list`.
```
{
"sd_job_name": "ecs-memcached",
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+"
},
```
Para la sección `metric_declaration`, la configuración predeterminada no permite ninguna métrica de Memcached. Agregue la siguiente sección para permitir métricas de Memcached. Asegúrese de seguir el patrón de sangría existente.
```
{
"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. Si ya implementó el agente de CloudWatch en el clúster de Amazon ECS mediante CloudFormation, puede crear un conjunto de cambios con los siguientes comandos.
```
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. 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 `memcached-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 mediante los siguientes comandos.
```
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 para el clúster por primera vez, ingrese los siguientes comandos:
```
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
```
## Visualización de las métricas de Memcached
En este tutorial se envían las siguientes métricas al espacio de nombres en CloudWatch **ECS/ContainerInsights/Prometheus**. Puede utilizar la consola de CloudWatch para ver las métricas de ese espacio de nombres.
| Nombre de métrica | Dimensiones |
| --- | --- |
| `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`, TaskDefinitionFamily, comando `ClusterName`, TaskDefinitionFamily, estado, comando |
**nota**
Los valores de la dimensión de **command** (comando) pueden ser: `delete`, `get`, `cas`, `set`, `decr`, `touch`, `incr` o `flush`.
Los valores de la dimensión **status** (estado) pueden ser: `hit`, `miss` o `badval`.
También puede crear un panel de CloudWatch para las métricas de Memcached Prometheus.
**Para crear un panel para las métricas de Memcached Prometheus**
1. Cree variables de entorno mediante el reemplazo de los siguientes valores para que concuerden con la implementación.
```
DASHBOARD_NAME=your_memcached_cw_dashboard_name
ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD
```
1. Ingrese el siguiente comando para crear el panel.
```
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
```
# Tutorial para el raspado de métricas de Redis OSS Prometheus en Amazon ECS Fargate
En este tutorial encontrará una introducción práctica para raspar las métricas de Prometheus de una aplicación de Redis OSS de muestra en un clúster de Amazon ECS Fargate. El destino del exportador de Redis OSS Prometheus será detectado automáticamente por el agente de CloudWatch con compatibilidad con métricas de Prometheus a partir de las etiquetas Docker del contenedor.
Redis OSS (https://redis.io/) es un almacén de estructuras de datos en memoria de código abierto (con licencia BSD), que se utiliza como base de datos, caché y agente de mensajes. Para obtener más información, consulte [redis](https://redis.io/).
redis\$1exporter (con licencia MIT) se utiliza para exponer las métricas de Redis OSS Prometheus en el puerto especificado (predeterminado: 0.0.0.0:9121). Para obtener más información, consulte [redis\$1exporter](https://github.com/oliver006/redis_exporter).
En este tutorial se utilizan las imágenes de Docker en los siguientes dos repositorios de Docker Hub:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [ redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Requisito previo**
Para recopilar métricas de una carga de trabajo de muestra de Prometheus para Amazon ECS, se debe ejecutar Información de contenedores en el clúster. Para obtener más información sobre la instalación de Información de contenedores, consulte [Configuración de Información de contenedores en Amazon ECS](deploy-container-insights-ECS.md).
**Topics**
+ [
## Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate
](#ContainerInsights-Prometheus-Setup-redis-ecs-variable)
+ [
## Establezca las variables de entorno de red para el clúster de Amazon ECS Fargate
](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2)
+ [
## Instale la carga de trabajo de muestra de Redis OSS
](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload)
+ [
## Configure el agente de CloudWatch para que raspe las métricas de Redis OSS Prometheus
](#ContainerInsights-Prometheus-Setup-redis-ecs-agent)
+ [
## Visualización de las métricas de Redis OSS
](#ContainerInsights-Prometheus-Setup-redis-view)
## Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate
**Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate**
1. Instale la CLI de Amazon ECS si aún no lo ha hecho. Para obtener más información, consulte [Installing the Amazon ECS CLI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html) (Instalación de la CLI de Amazon ECS).
1. Establezca el nuevo nombre del clúster de Amazon ECS y la Región. Por ejemplo:
```
ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (Opcional) Si aún no cuenta con un clúster de Amazon ECS Fargate en el que desea instalar la carga de trabajo de muestra de Redis OSS y el agente de CloudWatch, puede crear uno con el siguiente comando.
```
ecs-cli up --capability-iam \
--cluster $ECS_CLUSTER_NAME \
--launch-type FARGATE \
--region $AWS_DEFAULT_REGION
```
El resultado esperado de este comando es el siguiente:
```
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.
```
## Establezca las variables de entorno de red para el clúster de Amazon ECS Fargate
**Para establecer las variables de entorno de red para el clúster de Amazon ECS Fargate**
1. Establezca la VPC y el ID de subred del clúster de Amazon ECS. Si creó un clúster nuevo en el procedimiento anterior, verá estos valores en el resultado del comando final. De lo contrario, utilice los ID del clúster existente que va a utilizar con Redis.
```
ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx
```
1. En este tutorial, vamos a instalar la aplicación Redis OSS y el agente de CloudWatch en el grupo de seguridad predeterminado de la VPC del clúster de Amazon ECS. El grupo de seguridad predeterminado permite todas las conexiones de red dentro del mismo grupo de seguridad para que el agente de CloudWatch pueda raspar las métricas de Prometheus expuestas en los contenedores de Redis OSS. En un entorno de producción real, es posible que desee crear grupos de seguridad dedicados para la aplicación Redis OSS y el agente de CloudWatch y establecer permisos personalizados para estos.
Para obtener el ID del grupo de seguridad predeterminado, ingrese el siguiente comando.
```
aws ec2 describe-security-groups \
--filters Name=vpc-id,Values=$ECS_CLUSTER_VPC \
--region $AWS_DEFAULT_REGION
```
A continuación, establezca la variable de grupo de seguridad predeterminado del clúster de Fargate mediante el siguiente comando; debe reemplazar *my-default-security-group* por el valor que encontró del comando anterior.
```
ECS_CLUSTER_SECURITY_GROUP=my-default-security-group
```
## Instale la carga de trabajo de muestra de Redis OSS
**Para instalar la carga de trabajo de muestra de Redis OSS que expone las métricas de Prometheus**
1. Descargue la plantilla de CloudFormation de Redis OSS 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/sample_traffic/redis/redis-traffic-sample.yaml
```
1. Establezca los nombres de roles de IAM que se crearán para Redis OSS. Para ello, ingrese los siguientes comandos.
```
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. Instale la carga de trabajo de muestra de Redis OSS con el siguiente 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
```
La pila de CloudFormation crea cuatro recursos:
+ Un rol de tarea de ECS
+ Un rol de ejecución de tareas de ECS
+ Una definición de tarea de Redis OSS
+ Un servicio de Redis OSS
En la definición de tarea de Redis OSS, se definen dos contenedores:
+ El contenedor principal ejecuta una aplicación simple de Redis OSS y abre el puerto 6379 para el acceso.
+ El otro contenedor ejecuta el proceso exportador de Redis OSS para exponer las métricas de Prometheus en el puerto 9121. Este es el contenedor que el agente de CloudWatch detectará y raspará. La siguiente etiqueta docker se define para que el agente de CloudWatch pueda detectar este contenedor mediante ella.
```
ECS_PROMETHEUS_EXPORTER_PORT: 9121
```
## Configure el agente de CloudWatch para que raspe las métricas de Redis OSS Prometheus
**Para configurar el agente de CloudWatch para que raspe las métricas de Redis OSS Prometheus**
1. Descargue la última versión de `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` mediante 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-awsvpc.yaml
```
1. Abra el archivo con un editor de texto y busque la configuración completa del agente de CloudWatch detrás de la clave de `value` en la sección `resource:CWAgentConfigSSMParameter`.
A continuación, en la sección `ecs_service_discovery` que aparece aquí, la detección del servicio basada en `docker_label` se habilita con la configuración predeterminada que se basa en `ECS_PROMETHEUS_EXPORTER_PORT`, que coincide con la etiqueta docker que se definió en la definición de tarea de ECS de Redis OSS. Por lo tanto, no es necesario hacer ningún cambio en esta sección:
```
ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
* "docker_label": {
},*
...
```
Para la sección `metric_declaration`, la configuración predeterminada no permite ninguna métrica de Redis OSS. Agregue la siguiente sección para permitir las métricas de Redis OSS. Asegúrese de seguir el patrón de sangría existente.
```
{
"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. Si ya implementó el agente de CloudWatch en el clúster de Amazon ECS mediante CloudFormation, puede crear un conjunto de cambios con los siguientes comandos.
```
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. 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 `redis-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 mediante los siguientes comandos.
```
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. 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-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. Si va a instalar el agente de CloudWatch con la recopilación de métricas de Prometheus para el clúster por primera vez, ingrese los siguientes comandos:
```
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}
```
## Visualización de las métricas de Redis OSS
En este tutorial se envían las siguientes métricas al espacio de nombres en CloudWatch **ECS/ContainerInsights/Prometheus**. Puede utilizar la consola de CloudWatch para ver las métricas de ese espacio de nombres.
| Nombre de métrica | Dimensiones |
| --- | --- |
| `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**
Los valores de la dimensión **cmd** pueden ser: `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` o `slowlog`.
Los valores de la dimensión **db** pueden ir de `db0` a `db15`.
También puede crear un panel de CloudWatch para las métricas de Redis OSS Prometheus.
**Para crear un panel para las métricas de Redis OSS Prometheus**
1. Cree variables de entorno mediante el reemplazo de los siguientes valores para que concuerden con la implementación.
```
DASHBOARD_NAME=your_cw_dashboard_name
ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
```
1. Ingrese el siguiente comando para crear el panel.
```
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" \
```