Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate Establezca las variables de entorno de red para el clúster de Amazon ECS Fargate Instale la carga de trabajo de muestra de Redis Configure el agente de CloudWatch para que raspe las métricas de Redis Prometheus Visualización de las métricas de Redis

Tutorial para el raspado de métricas de Redis 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 de muestra en un clúster de Amazon ECS Fargate. El agente de CloudWatch con compatibilidad con las métricas de Prometheus basado en las etiquetas docker del contenedor detectará automáticamente el destino del exportador de Redis Prometheus.

Redis (https://redis.io/) es un almacén de estructuras de datos en memoria de código abierto (con licencia BSD), utilizado como base de datos, caché y agente de mensajes. Para obtener más información, consulte redis.

redis_exporter (con licencia MIT) se utiliza para exponer las métricas de Redis prometheus en el puerto especificado (predeterminado: 0.0.0.0:9121). Para obtener más información, consulte redis_exporter.

En este tutorial se utilizan las imágenes de Docker en los siguientes dos repositorios de Docker Hub:

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.

Temas

Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate
Establezca las variables de entorno de red para el clúster de Amazon ECS Fargate
Instale la carga de trabajo de muestra de Redis
Configure el agente de CloudWatch para que raspe las métricas de Redis Prometheus
Visualización de las métricas de Redis

Cómo establecer la variable de entorno del clúster de Amazon ECS Fargate

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 (Instalación de la CLI de Amazon ECS).
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
```

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

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
```
En este tutorial, vamos a instalar la aplicación Redis 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. En un entorno de producción real, es posible que desee crear grupos de seguridad dedicados para la aplicación Redis y el agente de CloudWatch y establecer permisos personalizados para ellos.

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

Para instalar la carga de trabajo de muestra de Redis que expone las métricas de Prometheus

Descargue la plantilla de AWS CloudFormation de Redis 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

Establezca los nombres de roles de IAM que se crearán para Redis al ingresar 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

Instale la carga de trabajo de muestra de Redis 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 AWS 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
Un servicio de Redis

En la definición de tarea de Redis, se definen dos contenedores:

El contenedor principal ejecuta una aplicación simple de Redis y abre el puerto 6379 para el acceso.
El otro contenedor ejecuta el proceso exportador de Redis 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 Prometheus

Para configurar el agente de CloudWatch para que raspe las métricas de Redis Prometheus

Descargue la última versión de cwagent-ecs-prometheus-metric-for-awsvpc.yaml 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-awsvpc.yaml

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 se muestra 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. 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. Agregue la siguiente sección para permitir las métricas de Redis. 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$"
  ]
},

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

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

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}

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

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 ser db0 o db15.

También puede crear un panel de CloudWatch para las métricas de Redis Prometheus.

Para crear un panel para las métricas de Redis Prometheus

Cree variables de entorno al reemplazar 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

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

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

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

Convenciones del documento

Tutorial para añadir un nuevo destino de raspado de Prometheus: Memcached en Amazon ECS

Establezca y configure los clústeres de Amazon EKS y de Kubernetes