# Supervisión de métricas de Información de contenedores de Prometheus La supervisión de Información de contenedores de CloudWatch para Prometheus automatiza la detección de métricas de Prometheus de cargas de trabajo y de sistemas en contenedores. Prometheus es un conjunto de herramientas de alerta y supervisión de sistemas de código abierto. Para obtener más información, consulte [s Prometheus?](https://prometheus.io/docs/introduction/overview/) en la documentación de Prometheus. La detección de métricas de Prometheus es compatible con los clústeres de [Amazon Elastic Container Service](https://aws.amazon.com/ecs/), [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/) y [Kubernetes](https://aws.amazon.com/kubernetes/) que se ejecutan en instancias de Amazon EC2. Se recopilan los tipos de métricas de contador, de medición y de resumen de Prometheus. Para los clústeres de Amazon ECS y de Amazon EKS, se admiten los tipos de lanzamiento de EC2 y Fargate. Información de contenedores recopila automáticamente métricas de varias cargas de trabajo, y puede configurarse para recopilar métricas de cualquier carga de trabajo. Puede adoptar Prometheus como método de código abierto y estándar abierto para capturar métricas personalizadas en CloudWatch. El agente de CloudWatch compatible con Prometheus detecta y recopila métricas de Prometheus para supervisar, solucionar errores y crear alarmas con más rapidez cuando el rendimiento de las aplicaciones se ve degradado y existen errores. Esto reduce también el número de herramientas de supervisión necesarias para mejorar la capacidad de observación. Información de contenedores de Prometheus permite utilizar un sistema de pago por uso con las métricas y registros, incluida su recopilación, almacenamiento y análisis. Para obtener más información, consulte [Precios de Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). **Paneles estándar para algunas cargas de trabajo** La solución Información de contenedores de Prometheus incluye paneles estándar para las cargas de trabajo populares que se enumeran en esta sección. Para obtener configuraciones de ejemplo para estas cargas de trabajo, consulte [(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) y [(Opcional) Configure las cargas de trabajo de muestra de Amazon EKS en contenedores para realizar pruebas con las métricas de Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md). También puede configurar Información de contenedores para que recopile métricas de Prometheus de otras aplicaciones y servicios en contenedores mediante la edición del archivo de configuración del agente. Las cargas de trabajo con paneles prediseñados para clústeres de Amazon EKS y de Kubernetes que se ejecutan en instancias de Amazon EC2: + AWS App Mesh + NGINX + Memcached + Java/JMX + HAProxy Cargas de trabajo con paneles prediseñados para clústeres de Amazon ECS: + AWS App Mesh + Java/JMX + NGINX + NGINX Plus # 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" \ ``` # Establezca y configure la recopilación de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes Para recopilar métricas de Prometheus de clústeres que ejecutan Amazon EKS o Kubernetes, puede utilizar el agente de CloudWatch como el recopilador de AWS Distro para OpenTelemetry. Para obtener información sobre el uso del recopilador de AWS Distro para OpenTelemetry, consulte [https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus). En las siguientes secciones se explica cómo se recopilan las métricas de Prometheus con el agente de CloudWatch. Explican cómo se instala el agente CloudWatch con supervisión de Prometheus en clústeres que ejecutan Amazon EKS o Kubernetes y cómo se configura el agente para que raspe los destinos adicionales. También proporcionan tutoriales opcionales para configurar cargas de trabajo de muestra para utilizarlas en pruebas con supervisión de Prometheus. **Topics** + [Instale el agente de CloudWatch con la colección de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes](ContainerInsights-Prometheus-Setup.md) # Instale el agente de CloudWatch con la colección de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes En esta sección se explica cómo se configura el agente de CloudWatch con supervisión de Prometheus en un clúster que ejecute Amazon EKS o Kubernetes. Después de hacerlo, el agente raspa e importa automáticamente las métricas para las siguientes cargas de trabajo que se ejecutan en ese clúster. + AWS App Mesh + NGINX + Memcached + Java/JMX + HAProxy + Fluent Bit También puede configurar el agente para que raspe e importe cargas de trabajo y fuentes de Prometheus adicionales. Antes de seguir estos pasos e instalar el agente de CloudWatch para recopilar métricas de Prometheus, debe contar con un clúster que se ejecute en Amazon EKS o un clúster de Kubernetes que se ejecute en una instancia de Amazon EC2. **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 de CloudWatch con la obtención de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes](#ContainerInsights-Prometheus-Setup-roles) + [El raspado de fuentes de Prometheus adicionales y la importación de tales métricas](ContainerInsights-Prometheus-Setup-configure.md) + [(Opcional) Configure las cargas de trabajo de muestra de Amazon EKS en contenedores para realizar pruebas con las métricas de Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md) ## Instale el agente de CloudWatch con la obtención de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes En esta sección se explica cómo se configura el agente de CloudWatch con supervisión de Prometheus en un clúster que ejecute Amazon EKS o Kubernetes. Después de hacerlo, el agente raspa e importa automáticamente las métricas para las siguientes cargas de trabajo que se ejecutan en ese clúster. + AWS App Mesh + NGINX + Memcached + Java/JMX + HAProxy + Fluent Bit También puede configurar el agente para que raspe e importe cargas de trabajo y fuentes de Prometheus adicionales. Antes de seguir estos pasos e instalar el agente de CloudWatch para recopilar métricas de Prometheus, debe contar con un clúster que se ejecute en Amazon EKS o un clúster de Kubernetes que se ejecute en una instancia de Amazon EC2. **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** + [Configuración de roles de IAM](#ContainerInsights-Prometheus-Setup-roles) + [Instalación del agente de CloudWatch para recopilar métricas de Prometheus](#ContainerInsights-Prometheus-Setup-install-agent) ### Configuración de roles de IAM El primer paso es configurar el rol de IAM necesario en el clúster. Hay dos métodos: + Configure un rol de IAM para una cuenta de servicio, también conocida como *Función de servicio*. Este método funciona tanto para el tipo de lanzamiento de EC2 como para el tipo de lanzamiento de Fargate. + Agregue una política de IAM al rol de IAM que se utiliza en el clúster. Esto solo funciona para el tipo de lanzamiento de EC2. **Configure una función de servicio (tipo de lanzamiento de EC2 y tipo de lanzamiento de Fargate)** Para configurar una función de servicio, ingrese el siguiente comando. Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create iamserviceaccount \ --name cwagent-prometheus \ --namespace amazon-cloudwatch \ --cluster MyCluster \ --attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \ --approve \ --override-existing-serviceaccounts ``` **Agregue una política al rol de IAM del grupo de nodos (solo tipo de lanzamiento de EC2)** **Para configurar la política de IAM en un grupo de nodos para la compatibilidad con Prometheus** 1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. En el panel de navegación, seleccione **Instances (Instancias)**. 1. Debe encontrar el prefijo en el nombre del rol de IAM de ese clúster. Para ello, active la casilla situada junto al nombre de una instancia del clúster y seleccione **Acciones**, **Seguridad**, **Modificar rol de IAM**. Después, copie el prefijo del rol de IAM; por ejemplo, `eksctl-dev303-workshop-nodegroup`. 1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Seleccione **Roles** en el panel de navegación. 1. Utilice el cuadro de búsqueda para buscar el prefijo que copió anteriormente en este procedimiento y elija ese rol. 1. Seleccione **Asociar políticas**. 1. Utilice el cuadro de búsqueda para buscar **CloudWatchAgentServerPolicy**. Active la casilla de verificación situada junto a **CloudWatchAgentServerPolicy** y elija **Asociar política**. ### Instalación del agente de CloudWatch para recopilar métricas de Prometheus Debe instalarse el agente de CloudWatch en el clúster para recopilar las métricas. La instalación del agente es diferente en los clústeres de Amazon EKS y en los de Kubernetes. **Elimine las versiones anteriores del agente de CloudWatch compatible con Prometheus** Si ya ha instalado en el clúster una versión del agente de CloudWatch compatible con Prometheus, debe eliminar esa versión con el siguiente comando. Solo es necesario hacerlo con las versiones anteriores del agente compatible con Prometheus. No es necesario que elimine el agente de CloudWatch que habilita Información de contenedores sin compatibilidad con Prometheus. ``` kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch ``` #### Instalación del agente de CloudWatch en clústeres de Amazon EKS con el tipo de lanzamiento de EC2 Para instalar el agente de CloudWatch compatible con Prometheus en un clúster de Amazon EKS, siga estos pasos. **Para instalar el agente de CloudWatch compatible con Prometheus en un clúster de Amazon EKS** 1. Ejecute el siguiente comando para comprobar si el espacio de nombres de `amazon-cloudwatch` ya se ha creado: ``` kubectl get namespace ``` 1. Si `amazon-cloudwatch` no aparece en los resultados, créelo con el siguiente comando: ``` kubectl create namespace amazon-cloudwatch ``` 1. Para implementar el agente con la configuración predeterminada y hacer que envíe datos a la región de AWS en la que está instalado, escriba el siguiente comando: ``` kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml ``` Para que el agente envíe datos a una otra región, siga estos pasos: 1. Descargue el archivo YAML del agente con el siguiente comando: ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml ``` 1. Abra el archivo con un editor de texto y busque el bloque `cwagentconfig.json` del archivo. 1. Agregue las líneas resaltadas, especificando la región que desee: ``` cwagentconfig.json: | { "agent": { "region": "us-east-2" }, "logs": { ... ``` 1. Guarde el archivo e implemente el agente utilizando el archivo actualizado. ``` kubectl apply -f prometheus-eks.yaml ``` #### Instalación del agente de CloudWatch en clústeres de Amazon EKS con el tipo de lanzamiento de Fargate Para instalar el agente de CloudWatch compatible con Prometheus en un clúster de Amazon EKS con el tipo de lanzamiento Fargate, siga estos pasos. **Para instalar el agente de CloudWatch compatible con Prometheus en un clúster de Amazon EKS con el tipo de lanzamiento de Fargate** 1. Ingrese el siguiente comando para crear un perfil de Fargate para el agente de CloudWatch de modo que pueda ejecutarse dentro del clúster. Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create fargateprofile --cluster MyCluster \ --name amazon-cloudwatch \ --namespace amazon-cloudwatch ``` 1. Para instalar el agente de CloudWatch, ingrese el siguiente comando. Sustituya *MyCluster* por el nombre del clúster. Este nombre se utiliza en el nombre del grupo de registros donde se almacenan los eventos de registro recopilados por el agente y también se utiliza como dimensión en las métricas recopiladas por el agente. Sustituya *Región* por el nombre de la Región a la que desea enviar la métrica. Por ejemplo, `us-west-1`. ``` curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" | kubectl apply -f - ``` #### Instalación del agente de CloudWatch en un clúster de Kubernetes Para instalar el agente de CloudWatch compatible con Prometheus en un clúster en el que se ejecuta Kubernetes, ingrese el siguiente comando: ``` curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" | kubectl apply -f - ``` Sustituya *MyCluster* por el nombre del clúster. Este nombre se utiliza en el nombre del grupo de registros donde se almacenan los eventos de registro recopilados por el agente y también se utiliza como dimensión en las métricas recopiladas por el agente. Sustituya *region* por el nombre de la región de AWS a la que desea enviar la métrica. Por ejemplo, **us-west-1**. #### Verifique que el agente esté en ejecución En los clústeres de Amazon EKS y en los de Kubernetes, puede ingresar el siguiente comando para confirmar que el agente se está ejecutando. ``` kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch ``` Si en los resultados solo aparece un pod del agente de CloudWatch con el estado `Running`, el agente está ejecutando y recopilando métricas de Prometheus. De forma predeterminada, el agente de CloudWatch recopila métricas para App Mesh, NGINX, Memcached, Java/JMX y HAProxy por minuto. Para obtener más información sobre estas métricas, consulte [Métricas de Prometheus que el agente de CloudWatch recopila](ContainerInsights-Prometheus-metrics.md). Para obtener instrucciones sobre cómo ver las métricas de Prometheus en CloudWatch, consulte [Visualización de las métricas de Prometheus](ContainerInsights-Prometheus-viewmetrics.md) También puede configurar el agente de CloudWatch para que recopile métricas de otros exportadores de Prometheus. Para obtener más información, consulte [El raspado de fuentes de Prometheus adicionales y la importación de tales métricas](ContainerInsights-Prometheus-Setup-configure.md). # El raspado de fuentes de Prometheus adicionales y la importación de tales 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 es para la configuración del agente de CloudWatch. Para los clústeres de Amazon EKS, las configuraciones se definen en `prometheus-eks.yaml` (para el tipo de lanzamiento de EC2) o en `prometheus-eks-fargate.yaml` (para el tipo de lanzamiento de Fargate) como dos mapas de configuración: + La sección `name: prometheus-config` contiene la configuración de extracción de Prometheus, + La sección `name: prometheus-cwagentconfig` contiene la configuración del agente de CloudWatch. Puede utilizar esta sección para definir cómo CloudWatch va a recopilar las métricas de Prometheus. Por ejemplo, puede especificar las métricas que se van a importar en CloudWatch y definir las dimensiones. Para los clústeres de Kubernetes que se ejecutan en las instancias de Amazon EC2, las configuraciones se definen en el archivo YAML `prometheus-k8s.yaml` como dos mapas de configuración: + La sección `name: prometheus-config` contiene la configuración de extracción de Prometheus, + La sección `name: prometheus-cwagentconfig` contiene la configuración del agente de CloudWatch. Para raspar las fuentes de las métricas de Prometheus adicionales e importarlas a CloudWatch, debe modifique tanto la configuración de raspado de Prometheus como la configuración del agente de CloudWatch y, a continuación, 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 `prometheus-eks.yaml`, los trabajos de raspado predeterminados se configuran en las líneas `job_name` en la sección `scrape_configs`. En este archivo, en la siguiente sección predeterminada `kubernetes-pod-jmx` se raspan las métricas de JMX exporter. ``` - job_name: 'kubernetes-pod-jmx' sample_limit: 10000 metrics_path: /metrics kubernetes_sd_configs: - role: pod relabel_configs: - source_labels: [__address__] action: keep regex: '.*:9404$' - action: labelmap regex: __meta_kubernetes_pod_label_(.+) - action: replace source_labels: - __meta_kubernetes_namespace target_label: Namespace - source_labels: [__meta_kubernetes_pod_name] action: replace target_label: pod_name - action: replace source_labels: - __meta_kubernetes_pod_container_name target_label: container_name - action: replace source_labels: - __meta_kubernetes_pod_controller_name target_label: pod_controller_name - action: replace source_labels: - __meta_kubernetes_pod_controller_kind target_label: pod_controller_kind - action: replace source_labels: - __meta_kubernetes_pod_phase target_label: pod_phase ``` Se realiza el raspado de cada uno de estos destinos predeterminados y las métricas se envían a CloudWatch en eventos de registro mediante el 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 EKS y de Kubernetes se almacenan en el grupo de registro **//aws/containerinsights/*cluster\$1name*/prometheus** en CloudWatch Logs. Los eventos de registro de los clústeres de Amazon ECS se almacenan en el grupo de registro **/aws/ecs/containerinsights/*cluster\$1name*/prometheus**. Cada trabajo de extracción está contenido en un flujo de registros diferente en este grupo de registros. Por ejemplo, el trabajo de raspado de Prometheus `kubernetes-pod-appmesh-envoy` se define para App Mesh. Todas las métricas de Prometheus de App Mesh de los clústeres de Amazon EKS y de Kubernetes se envían al flujo de registros denominado **/aws/containerinsights/*cluster\$1name*>prometheus/kubernetes-pod-appmesh-envoy/**. Para agregar un nuevo destino de extracción, agregue una nueva sección `job_name` a la sección `scrape_configs` del archivo YAML y reinicie 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-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 EKS o de Kubernetes. + **log\$1group\$1name**: especifica el nombre del grupo de registros para las métricas Prometheus raspadas. Este campo es opcional. Si lo omite, CloudWatch utiliza **/aws/containerinsights/*cluster\$1name*/prometheus** para los registros de los clústeres de Amazon EKS y de Kubernetes. + **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 en la que se especifica la configuración para la detección de servicios de Prometheus de Amazon ECS. Para obtener más información, consulte [Guía detallada para la detección automática en clústeres de Amazon ECS](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md). 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 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", ... } ``` ## Tutorial para agregar un destino de raspado nuevo de Prometheus: métricas del servidor de la API de Prometheus El servidor de la API de Kubernetes expone métricas de Prometheus en los puntos de enlace de forma predeterminada. El ejemplo oficial de la configuración de extracción del servidor de la API de Kubernetes está disponible en [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml). El siguiente tutorial muestra cómo se realizan los siguientes pasos para comenzar a importar métricas del servidor de la API de Kubernetes a CloudWatch: + Agregue la configuración de raspado de Prometheus para el servidor de la API de Kubernetes al archivo YAML del agente de CloudWatch. + Configuración de las definiciones de métricas del formato de métrica integrada en el archivo YAML del agente de CloudWatch. + (Opcional) Creación de un panel de CloudWatch para las métricas del servidor de la API de Kubernetes. **nota** El servidor de la API de Kubernetes expone métricas de medidor, contador, histograma y resumen. En esta versión de compatibilidad con métricas de Prometheus, CloudWatch importa solo las métricas con tipos de medidor, contador y de resumen. **Para comenzar a recopilar métricas del servidor de la API de Kubernetes de Prometheus en CloudWatch** 1. Descargue la última versión del archivo `prometheus-eks.yaml`, `prometheus-eks-fargate.yaml` o `prometheus-k8s.yaml` con uno de los siguientes comandos. En el caso de un clúster de Amazon EKS con el tipo de lanzamiento de EC2, ingrese el siguiente comando: ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml ``` En el caso de un clúster de Amazon EKS con el tipo de lanzamiento de Fargate, ingrese el siguiente comando: ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml ``` En los clústeres de Kubernetes que se ejecuten en una instancia de Amazon EC2, ingrese el siguiente comando: ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml ``` 1. Abra el archivo con un editor de texto, busque la sección `prometheus-config` y agregue la siguiente sección dentro de esa sección. Para guardar los cambios: ``` # Scrape config for API servers - job_name: 'kubernetes-apiservers' kubernetes_sd_configs: - role: endpoints namespaces: names: - default scheme: https tls_config: ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt insecure_skip_verify: true bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token relabel_configs: - source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name] action: keep regex: kubernetes;https - action: replace source_labels: - __meta_kubernetes_namespace target_label: Namespace - action: replace source_labels: - __meta_kubernetes_service_name target_label: Service ``` 1. Con el archivo YAML abierto en el editor de texto, busque la sección `cwagentconfig.json`. Agregue la subsección siguiente y guarde los cambios. Esta sección coloca las métricas de servicio de la API en la lista de permitidos del agente de CloudWatch. Se agregan tres tipos de métricas de servidor de la API a la lista de permitidos: + Recuentos de objetos etcd + Métricas del controlador de registro del servidor de la API + Métricas de solicitud del servidor de la API ``` {"source_labels": ["job", "resource"], "label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)", "dimensions": [["ClusterName","Service","resource"]], "metric_selectors": [ "^etcd_object_counts$" ] }, {"source_labels": ["job", "name"], "label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$", "dimensions": [["ClusterName","Service","name"]], "metric_selectors": [ "^workqueue_depth$", "^workqueue_adds_total$", "^workqueue_retries_total$" ] }, {"source_labels": ["job","code"], "label_matcher": "^kubernetes-apiservers;2[0-9]{2}$", "dimensions": [["ClusterName","Service","code"]], "metric_selectors": [ "^apiserver_request_total$" ] }, {"source_labels": ["job"], "label_matcher": "^kubernetes-apiservers", "dimensions": [["ClusterName","Service"]], "metric_selectors": [ "^apiserver_request_total$" ] }, ``` 1. Si el agente de CloudWatch compatible con Prometheus ya está implementado en el clúster, debe eliminarlo con el siguiente comando: ``` kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch ``` 1. Implemente el agente de CloudWatch con la configuración actualizada mediante uno de los siguientes comandos. Para un clúster de Amazon EKS con el tipo de lanzamiento de EC2, ingrese: ``` kubectl apply -f prometheus-eks.yaml ``` Para un clúster de Amazon EKS con el tipo de lanzamiento de Fargate, ingrese el siguiente comando. Reemplace *MyCluster* y *Región* con valores que concuerden con la implementación. ``` cat prometheus-eks-fargate.yaml \ | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \ | kubectl apply -f - ``` En los clústeres de Kubernetes, ingrese el siguiente comando: Reemplace *MyCluster* y *Región* con valores que concuerden con la implementación. ``` cat prometheus-k8s.yaml \ | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \ | kubectl apply -f - ``` Una vez hecho esto, debería ver un nuevo flujo de registros denominado **kubernetes-apiservers** en el grupo de registros **/aws/containerinsights/*nombre\$1clúster*/prometheus**. Esta secuencia de registros debe incluir eventos de registro con una definición de formato de métricas integradas como la siguiente: ``` { "CloudWatchMetrics":[ { "Metrics":[ { "Name":"apiserver_request_total" } ], "Dimensions":[ [ "ClusterName", "Service" ] ], "Namespace":"ContainerInsights/Prometheus" } ], "ClusterName":"my-cluster-name", "Namespace":"default", "Service":"kubernetes", "Timestamp":"1592267020339", "Version":"0", "apiserver_request_count":0, "apiserver_request_total":0, "code":"0", "component":"apiserver", "contentType":"application/json", "instance":"192.0.2.0:443", "job":"kubernetes-apiservers", "prom_metric_type":"counter", "resource":"pods", "scope":"namespace", "verb":"WATCH", "version":"v1" } ``` Puede visualizar las métricas en la consola de CloudWatch, en el espacio de nombres **ContainerInsights/Prometheus**. También tiene la opción de crear un panel de CloudWatch para las métricas del servidor de la API de Kubernetes de Prometheus. ### (Opcional) Creación de un panel para las métricas del servidor de la API de Kubernetes. Para ver las métricas del servidor de la API de Kubernetes en el panel, primero debe haber completado los pasos de las secciones anteriores para comenzar a recopilar estas métricas en CloudWatch. **Para crear un panel para las métricas del servidor de la API de Kubernetes** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Asegúrese de tener seleccionada la región de AWS correcta. 1. En el panel de navegación, seleccione **Paneles**. 1. Elija **Crear un panel**. Escriba el nombre del nuevo panel y elija **Crear un panel**. 1. En **Añadir a este panel**, elija **Cancelar**. 1. Elija **Actions (Acciones)**, **View/edit source (Ver/editar código fuente)**. 1. Descargue el siguiente archivo JSON: [Kubernetes API Dashboard source](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json). 1. Abra el archivo JSON que descargó con un editor de texto y realice los siguientes cambios: + Reemplace todas las cadenas `{{YOUR_CLUSTER_NAME}}` por el nombre exacto del clúster. Tenga cuidado de no agregar espacios en blanco antes o después del texto. + Reemplace todas las cadenas `{{YOUR_AWS_REGION}}` por el nombre de la región donde se recopilan las métricas. Por ejemplo: . `us-west-2`. Asegúrese de no agregar espacios en blanco antes o después del texto. 1. Copie todo el blob JSON y péguelo en el cuadro de texto de la consola de CloudWatch de modo que sustituya lo que ya se encuentra en el cuadro. 1. Elija **Actualizar** y **Guardar el panel**. # (Opcional) Configure las cargas de trabajo de muestra de Amazon EKS en contenedores 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). Para poder instalar cualquiera de estas cargas de trabajo, debe instalar Helm 3.x con los siguientes comandos: ``` brew install helm ``` Para obtener más información, consulte [Helm](https://helm.sh). **Topics** + [Configuración de las cargas de trabajo de muestra de AWS App Mesh para Amazon EKS y Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md) + [Configure NGINX con tráfico de muestra en Amazon EKS y Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md) + [Configure memcached con un exportador de métricas en Amazon EKS y Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md) + [Configure la carga de trabajo de muestra de Java/JMX en Amazon EKS y Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md) + [Configure HAProxy con un exportador de métricas en Amazon EKS y Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md) + [Tutorial para agregar un nuevo destino de raspado de Prometheus: Redis OSS en clústeres de Amazon EKS y de Kubernetes](ContainerInsights-Prometheus-Setup-redis-eks.md) # Configuración de las cargas de trabajo de muestra de AWS App Mesh para Amazon EKS y Kubernetes La compatibilidad de Prometheus con Información de contenedores de CloudWatch es compatible con AWS App Mesh. En las secciones siguientes se explica cómo se configura App Mesh. **Topics** + [Configuración de la carga de trabajo de muestra de AWS App Mesh en un clúster de Amazon EKS con el tipo de lanzamiento de EC2 o en un clúster de Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md) + [Configuración de la carga de trabajo de muestra de AWS App Mesh en un clúster de Amazon EKS con el tipo de lanzamiento de Fargate](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md) # Configuración de la carga de trabajo de muestra de AWS App Mesh en un clúster de Amazon EKS con el tipo de lanzamiento de EC2 o en un clúster de Kubernetes Siga estas instrucciones si está configurando App Mesh en un clúster que ejecute Amazon EKS con el tipo de lanzamiento de EC2 o en un clúster de Kubernetes. ## Configure los permisos de IAM Debe agregar la política **AWSAppMeshFullAccess** al rol de IAM del grupo de nodos de Amazon EKS o Kubernetes. En Amazon EKS, el nombre de este grupo de nodos es similar a `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL`. En Kubernetes, podría ser parecido a `nodes.integ-test-kops-prometheus.k8s.local`. ## Instale App Mesh Para instalar el controlador App Mesh Kubernetes, siga las instrucciones que se indican en [App Mesh Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller) (Controlador de App Mesh). ## Instale una aplicación de muestra [aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples) contiene varias explicaciones de Kubernetes App Mesh. Para este tutorial, se instala una aplicación de color de muestra en la que se puede ver cómo las rutas http pueden utilizar cabeceras para hacer concordar las peticiones entrantes. **Para utilizar una aplicación de ejemplo App Mesh para probar Información de contenedores** 1. Instale la aplicación con estas instrucciones: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers). 1. Lance un pod curler para generar tráfico: ``` kubectl -n default run -it curler --image=tutum/curl /bin/bash ``` 1. Utilice el comando curl con diferentes puntos de enlace al cambiar las cabeceras HTTP. Ejecute el comando curl varias veces, como se muestra: ``` curl -H "color_header: blue" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo; curl -H "color_header: red" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo; curl -H "color_header: yellow" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo; ``` 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En la región de AWS en la que se está ejecutando el clúster, elija **Metrics** (Métricas) en el panel de navegación. Las métricas están en el espacio de nombres **ContainerInsights/Prometheus**. 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_cluster_name/prometheus ` en el flujo de registros `kubernetes-pod-appmesh-envoy`. ## Eliminación del entorno de prueba de App Mesh Cuando haya terminado de usar App Mesh y la aplicación de muestra, utilice los siguientes comandos para eliminar los recursos innecesarios. Elimine la aplicación de muestra con el siguiente comando: ``` cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/ kubectl delete -f _output/manifest.yaml ``` Elimine el controlador de App Mesh con el siguiente comando: ``` helm delete appmesh-controller -n appmesh-system ``` # Configuración de la carga de trabajo de muestra de AWS App Mesh en un clúster de Amazon EKS con el tipo de lanzamiento de Fargate Siga estas instrucciones si está configurando App Mesh en un clúster que ejecute Amazon EKS con el tipo de lanzamiento de Fargate. ## Configure los permisos de IAM Para configurar los permisos de IAM, ingrese el siguiente comando. Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create iamserviceaccount --cluster MyCluster \ --namespace howto-k8s-fargate \ --name appmesh-pod \ --attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \ --attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \ --override-existing-serviceaccounts \ --approve ``` ## Instale App Mesh Para instalar el controlador de App Mesh Kubernetes, siga las instrucciones que se indican en [App Mesh Controller](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller) (Controlador de App Mesh). Asegúrese de seguir las instrucciones de Amazon EKS con el tipo de lanzamiento de Fargate. ## Instale una aplicación de muestra [aws-app-mesh-ejemplos](https://github.com/aws/aws-app-mesh-examples) contiene varias explicaciones de Kubernetes App Mesh. Para este tutorial, se instala una aplicación de color de muestra que funcione para clústeres de Amazon EKS con el tipo de lanzamiento de Fargate. **Para utilizar una aplicación de muestra App Mesh para probar Información de contenedores** 1. Instale la aplicación con estas instrucciones: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate). Esas instrucciones suponen que está creando un nuevo clúster con el perfil de Fargate correcto. Si desea utilizar un clúster de Amazon EKS que ya haya configurado, puede utilizar los siguientes comandos para configurar dicho clúster para esta demostración. Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create iamserviceaccount --cluster MyCluster \ --namespace howto-k8s-fargate \ --name appmesh-pod \ --attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \ --attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \ --attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \ --override-existing-serviceaccounts \ --approve ``` ``` eksctl create fargateprofile --cluster MyCluster \ --namespace howto-k8s-fargate --name howto-k8s-fargate ``` 1. Reenvíe el despliegue de la aplicación frontal: ``` kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080 ``` 1. Utilice el comando curl en la aplicación frontal: ``` while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done ``` 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En la región de AWS en la que se está ejecutando el clúster, elija **Metrics** (Métricas) en el panel de navegación. Las métricas están en el espacio de nombres **ContainerInsights/Prometheus**. 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_cluster_name/prometheus ` en el flujo de registros `kubernetes-pod-appmesh-envoy`. ## Eliminación del entorno de prueba de App Mesh Cuando haya terminado de usar App Mesh y la aplicación de muestra, utilice los siguientes comandos para eliminar los recursos innecesarios. Elimine la aplicación de muestra con el siguiente comando: ``` cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/ kubectl delete -f _output/manifest.yaml ``` Elimine el controlador de App Mesh con el siguiente comando: ``` helm delete appmesh-controller -n appmesh-system ``` # Configure NGINX con tráfico de muestra en Amazon EKS y Kubernetes NGINX es un servidor web que también se puede utilizar como balanceador de carga y como proxy inverso. Para obtener más información sobre cómo Kubernetes utiliza NGINX para las entradas, consulte [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx). **Para instalar Ingress-NGINX con un servicio de tráfico de ejemplo para probar la compatibilidad de Información de contenedores de Prometheus** 1. Ingrese el siguiente comando para agregar el repositorio de nginx de acceso de Helm. ``` helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx ``` 1. Ejecute los comandos siguientes: ``` kubectl create namespace nginx-ingress-sample helm install my-nginx ingress-nginx/ingress-nginx \ --namespace nginx-ingress-sample \ --set controller.metrics.enabled=true \ --set-string controller.metrics.service.annotations."prometheus\.io/port"="10254" \ --set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true" ``` 1. Compruebe si los servicios se iniciaron correctamente con el siguiente comando: ``` kubectl get service -n nginx-ingress-sample ``` Deberían aparecer varias columnas, como la columna `EXTERNAL-IP`. 1. Defina una variable `EXTERNAL-IP` con el valor de la columna `EXTERNAL-IP` que aparece en la fila del controlador de entrada de NGINX. ``` EXTERNAL_IP=your-nginx-controller-external-ip ``` 1. Ponga en marcha cierto tráfico de NGINX de ejemplo con el siguiente comando. ``` SAMPLE_TRAFFIC_NAMESPACE=nginx-sample-traffic curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/nginx-traffic/nginx-traffic-sample.yaml | sed "s/{{external_ip}}/$EXTERNAL_IP/g" | sed "s/{{namespace}}/$SAMPLE_TRAFFIC_NAMESPACE/g" | kubectl apply -f - ``` 1. Utilice el siguiente comando para confirmar que los tres pods tienen el estado `Running`. ``` kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE ``` Si se están ejecutando, enseguida aparecerán las métricas en el espacio de nombres **ContainerInsights/Prometheus** . **Para desinstalar NGINX y la aplicación de tráfico de ejemplo** 1. Elimine el servicio de tráfico de ejemplo con el siguiente comando: ``` kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE ``` 1. Elimine la salida de NGINX por el nombre de versión de Helm. ``` helm uninstall my-nginx --namespace nginx-ingress-sample kubectl delete namespace nginx-ingress-sample ``` # Configure memcached con un exportador de métricas en Amazon EKS y Kubernetes Memcached es un sistema de almacenamiento en caché de objetos de memoria de código abierto. Para obtener más información, consulte [What is Memcached?](https://www.memcached.org). Si está ejecutando memcached en un clúster con el tipo de lanzamiento de Fargate, debe configurar un perfil de Fargate antes de seguir los pasos de este procedimiento. Para configurar el perfil, ingrese el siguiente comando: Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create fargateprofile --cluster MyCluster \ --namespace memcached-sample --name memcached-sample ``` **Si desea instalar Memcached con un exportador de métricas para probar la compatibilidad de Información de contenedores de Prometheus** 1. Utilice el siguiente comando para agregar el repositorio. ``` helm repo add bitnami https://charts.bitnami.com/bitnami ``` 1. Utilice el siguiente comando para crear un nuevo espacio de nombres: ``` kubectl create namespace memcached-sample ``` 1. Utilice el siguiente comando para instalar Memcached: ``` helm install my-memcached bitnami/memcached --namespace memcached-sample \ --set metrics.enabled=true \ --set-string serviceAnnotations.prometheus\\.io/port="9150" \ --set-string serviceAnnotations.prometheus\\.io/scrape="true" ``` 1. Utilice el siguiente comando para confirmar la anotación del servicio en ejecución: ``` kubectl describe service my-memcached-metrics -n memcached-sample ``` Debería ver estas dos anotaciones: ``` Annotations: prometheus.io/port: 9150 prometheus.io/scrape: true ``` **Para desinstalar Memcached** + Ejecute los comandos siguientes: ``` helm uninstall my-memcached --namespace memcached-sample kubectl delete namespace memcached-sample ``` # Configure la carga de trabajo de muestra de Java/JMX en Amazon EKS y Kubernetes 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). Información de contenedores puede recopilar métricas de Prometheus predefinidas de Java Virtual Machine (JVM), Java y Tomcat (Catalina) usando JMX Exporter. ## Configuración predeterminada de raspado de Prometheus De forma predeterminada, el agente de CloudWatch compatible con Prometheus raspa las métricas de Java/JMX de Prometheus de `http://CLUSTER_IP:9404/metrics` en cada pod en un clúster de Amazon EKS o de Kubernetes. Esto se realiza por la detección del `role: pod` de Prometheus `kubernetes_sd_config`. 9404 es el puerto predeterminado que Prometheus asignó para JMX Exporter. Para obtener más información acerca de la detección `role: pod`, consulte [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). 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 scrape\$1config de jmx predeterminada en el mapa de configuración del agente de CloudWatch. Ejecute el siguiente comando para obtener la configuración de Prometheus del agente de CloudWatch actual: ``` kubectl describe cm prometheus-config -n amazon-cloudwatch ``` Los campos que se van a modificar son `/metrics` y `regex: '.*:9404$'`, que aparecen resaltados en el siguiente ejemplo. ``` job_name: 'kubernetes-jmx-pod' sample_limit: 10000 metrics_path: /metrics kubernetes_sd_configs: - role: pod relabel_configs: - source_labels: [__address__] action: keep regex: '.*:9404$' - action: replace regex: (.+) source_labels: ``` ## Otra configuración de raspado de Prometheus Si expone la aplicación que se ejecuta en un conjunto de pods con exportadores de Java/JMX Prometheus por un servicio Kubernetes, también puede cambiar el uso de la detección de `role: service` o la detección del `role: endpoint` de Prometheus `kubernetes_sd_config`. Para obtener más información sobre estos métodos de detección, consulte [service](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service) (servicio), [endpoints](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints) (puntos de enlace) y [.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config). Estos dos modos de detección de servicios proporcionan más metaetiquetas que podrían ser útiles para crear las dimensiones de métricas de CloudWatch. Por ejemplo, puede volver a etiquetar `__meta_kubernetes_service_name` a `Service` e incluirla en la dimensión de las métricas. Para obtener más información sobre cómo se personalizan las métricas de CloudWatch y las dimensiones, consulte [Configuración del agente de CloudWatch para Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config). ## Imagen de Docker con JMX Exporter A continuación, cree una imagen de Docker. En las siguientes secciones, se incluyen dos Dockerfiles de muestra. Cuando haya creado la imagen, cárguela en Amazon EKS o Kubernetes y ejecute el siguiente comando para verificar que `JMX_EXPORTER` ha expuesto las métricas de Prometheus en el puerto 9404. Sustituya *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD* por el nombre del pod en ejecución y *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* por el espacio de nombres de la aplicación. Si está ejecutando JMX Exporter en un clúster con el tipo de lanzamiento de Fargate, también debe configurar un perfil de Fargate antes de seguir los pasos de este procedimiento. Para configurar el perfil, ingrese el comando siguiente: Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create fargateprofile --cluster MyCluster \ --namespace $JAR_SAMPLE_TRAFFIC_NAMESPACE\ --name $JAR_SAMPLE_TRAFFIC_NAMESPACE ``` ``` kubectl exec $JAR_SAMPLE_TRAFFIC_POD -n $JARCAT_SAMPLE_TRAFFIC_NAMESPACE -- curl http://localhost:9404 ``` ## Ejemplo: Imagen de Apache Tomcat Docker con métricas de Prometheus De forma predeterminada, el servidor Apache Tomcat expone mBeans de JMX. Puede integrar JMX Exporter con Tomcat para que los mBeans de JMX se expongan como métricas de Prometheus. En el siguiente Dockerfile de ejemplo, se indican los pasos para crear una imagen de prueba: ``` # From Tomcat 9.0 JDK8 OpenJDK FROM tomcat:9.0-jdk8-openjdk RUN mkdir -p /opt/jmx_exporter COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter COPY ./config.yaml /opt/jmx_exporter COPY ./setenv.sh /usr/local/tomcat/bin COPY your web application.war /usr/local/tomcat/webapps/ RUN chmod o+x /usr/local/tomcat/bin/setenv.sh ENTRYPOINT ["catalina.sh", "run"] ``` En la siguiente lista, se explican las cuatro líneas `COPY` de este Dockerfile. + Descargue el último archivo jar de JMX Exporter de [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter). + `config.yaml` es el archivo de configuración de JMX Exporter. Para obtener más información, consulte [https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ). Este es un archivo de configuración de ejemplo para Java y Tomcat: ``` lowercaseOutputName: true lowercaseOutputLabelNames: true rules: - pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)' name: java_lang_OperatingSystem_$1 type: GAUGE - pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)' name: java_lang_threading_$1 type: GAUGE - pattern: 'Catalina<>(\w+)' name: catalina_globalrequestprocessor_$3_total labels: port: "$2" protocol: "$1" help: Catalina global $3 type: COUNTER - pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)' name: catalina_servlet_$3_total labels: module: "$1" servlet: "$2" help: Catalina servlet $3 total type: COUNTER - pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)' name: catalina_threadpool_$3 labels: port: "$2" protocol: "$1" help: Catalina threadpool $3 type: GAUGE - pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)' name: catalina_session_$3_total labels: context: "$2" host: "$1" help: Catalina session $3 total type: COUNTER - pattern: ".*" ``` + `setenv.sh` es un script de startup de Tomcat que abre JMX Exporter junto con Tomcat y expone las métricas de Prometheus en el puerto 9404 de localhost. También proporciona a JMX Exporter la ruta del archivo `config.yaml`. ``` $ cat setenv.sh export JAVA_OPTS="-javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml $JAVA_OPTS" ``` + application.war es el archivo de aplicación web `war` que se va a cargar en Tomcat. Cree una imagen de Docker con esta configuración y cárguela en un repositorio de imágenes. ## Ejemplo: Imagen de Docker de una aplicación Jar de Java con métricas de Prometheus En el siguiente Dockerfile de muestra, se indican los pasos para crear una imagen de prueba: ``` # Alpine Linux with OpenJDK JRE FROM openjdk:8-jre-alpine RUN mkdir -p /opt/jmx_exporter COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter COPY ./SampleJavaApplication-1.0-SNAPSHOT.jar /opt/jmx_exporter COPY ./start_exporter_example.sh /opt/jmx_exporter COPY ./config.yaml /opt/jmx_exporter RUN chmod -R o+x /opt/jmx_exporter RUN apk add curl ENTRYPOINT exec /opt/jmx_exporter/start_exporter_example.sh ``` En la siguiente lista, se explican las cuatro líneas `COPY` de este Dockerfile. + Descargue el último archivo jar de JMX Exporter de [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter). + `config.yaml` es el archivo de configuración de JMX Exporter. Para obtener más información, consulte [https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ). Este es un archivo de configuración de ejemplo para Java y Tomcat: ``` lowercaseOutputName: true lowercaseOutputLabelNames: true rules: - pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)' name: java_lang_OperatingSystem_$1 type: GAUGE - pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)' name: java_lang_threading_$1 type: GAUGE - pattern: 'Catalina<>(\w+)' name: catalina_globalrequestprocessor_$3_total labels: port: "$2" protocol: "$1" help: Catalina global $3 type: COUNTER - pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)' name: catalina_servlet_$3_total labels: module: "$1" servlet: "$2" help: Catalina servlet $3 total type: COUNTER - pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)' name: catalina_threadpool_$3 labels: port: "$2" protocol: "$1" help: Catalina threadpool $3 type: GAUGE - pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)' name: catalina_session_$3_total labels: context: "$2" host: "$1" help: Catalina session $3 total type: COUNTER - pattern: ".*" ``` + `start_exporter_example.sh` es el script para iniciar la aplicación JAR con las métricas de Prometheus exportadas. También proporciona a JMX Exporter la ruta del archivo `config.yaml`. ``` $ cat start_exporter_example.sh java -javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml -cp /opt/jmx_exporter/SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App ``` + SampleJavaApplication-1.0-SNAPSHOT.jar es el archivo jar de la aplicación Java de ejemplo. Sustitúyalo por la aplicación Java que desee supervisar. Cree una imagen de Docker con esta configuración y cárguela en un repositorio de imágenes. # Configure HAProxy con un exportador de métricas en Amazon EKS y Kubernetes HAProxy es una aplicación proxy de código abierto. Para obtener más información, consulte [HAProxy](https://www.haproxy.org). Si está ejecutando HAProxy en un clúster con el tipo de lanzamiento de Fargate, debe configurar un perfil de Fargate antes de seguir los pasos de este procedimiento. Para configurar el perfil, ingrese el siguiente comando: Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create fargateprofile --cluster MyCluster \ --namespace haproxy-ingress-sample --name haproxy-ingress-sample ``` **Si desea instalar HAProxy con un exportador de métricas para probar la compatibilidad de Información de contenedores de Prometheus** 1. Ejecute el siguiente comando para agregar el repositorio de incubación de Helm: ``` helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts ``` 1. Utilice el siguiente comando para crear un nuevo espacio de nombres: ``` kubectl create namespace haproxy-ingress-sample ``` 1. Ejecute los siguientes comandos para instalar HAProxy: ``` helm install haproxy haproxy-ingress/haproxy-ingress \ --namespace haproxy-ingress-sample \ --set defaultBackend.enabled=true \ --set controller.stats.enabled=true \ --set controller.metrics.enabled=true \ --set-string controller.metrics.service.annotations."prometheus\.io/port"="9101" \ --set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true" ``` 1. Ejecute el siguiente comando para confirmar la anotación del servicio: ``` kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample ``` Debería ver las siguientes anotaciones. ``` Annotations: prometheus.io/port: 9101 prometheus.io/scrape: true ``` **Para desinstalar HAProxy** + Ejecute los comandos siguientes: ``` helm uninstall haproxy --namespace haproxy-ingress-sample kubectl delete namespace haproxy-ingress-sample ``` # Tutorial para agregar un nuevo destino de raspado de Prometheus: Redis OSS en clústeres de Amazon EKS y de Kubernetes Este tutorial proporciona una introducción práctica para raspar las métricas de Prometheus de una aplicación de muestra de Redis OSS en Amazon EKS y Kubernetes. Redis OSS (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](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) **Para instalar una carga de trabajo de Redis OSS de muestra que exponga las métricas de Prometheus** 1. Establezca el espacio de nombres para la carga de trabajo de Redis OSS de muestra. ``` REDIS_NAMESPACE=redis-sample ``` 1. Si ejecuta Redis OSS en un clúster con el tipo de lanzamiento de Fargate, debe configurar un perfil de Fargate. Para configurar el perfil, ingrese el siguiente comando: Sustituya *MyCluster* por el nombre del clúster. ``` eksctl create fargateprofile --cluster MyCluster \ --namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE ``` 1. Ingrese el siguiente comando para instalar la carga de trabajo de Redis OSS de muestra. ``` curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml \ | sed "s/{{namespace}}/$REDIS_NAMESPACE/g" \ | kubectl apply -f - ``` 1. La instalación incluye un servicio llamado `my-redis-metrics` que expone la métrica de Redis OSS Prometheus en el puerto 9121; ingrese el siguiente comando para obtener los detalles del servicio: ``` kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE ``` En la sección `Annotations` de los resultados, verá dos anotaciones que concuerdan con la configuración de raspado de Prometheus del agente de CloudWatch, para que pueda detectar automáticamente las cargas de trabajo: ``` prometheus.io/port: 9121 prometheus.io/scrape: true ``` La configuración de raspado de Prometheus relacionada se encuentra en la sección `- job_name: kubernetes-service-endpoints`de `kubernetes-eks.yaml` o `kubernetes-k8s.yaml`. **Para empezar a recopilar métricas de Redis OSS Prometheus en CloudWatch** 1. Descargue la última versión del archivo de `kubernetes-eks.yaml` o el archivo `kubernetes-k8s.yaml` con uno de los siguientes comandos. Para un clúster de Amazon EKS con el tipo de lanzamiento de EC2, ingrese este comando. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml ``` Para un clúster de Amazon EKS con el tipo de lanzamiento de Fargate, ingrese este comando. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml ``` En los clústeres de Kubernetes que se ejecuten en una instancia de Amazon EC2, ingrese el siguiente comando. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml ``` 1. Abra el archivo con un editor de texto y busque la sección `cwagentconfig.json`. Agregue la subsección siguiente y guarde los cambios. Asegúrese de seguir el patrón existente de sangría. ``` { "source_labels": ["pod_name"], "label_matcher": "^redis-instance$", "dimensions": [["Namespace","ClusterName"]], "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": ["pod_name"], "label_matcher": "^redis-instance$", "dimensions": [["Namespace","ClusterName","cmd"]], "metric_selectors": [ "^redis_commands_total$" ] }, { "source_labels": ["pod_name"], "label_matcher": "^redis-instance$", "dimensions": [["Namespace","ClusterName","db"]], "metric_selectors": [ "^redis_db_keys$" ] }, ``` La sección que agregó coloca las métricas de Redis OSS en la lista de permitidos del agente de CloudWatch. Para obtener la lista de estas métricas, consulte la siguiente sección. 1. Si el agente de CloudWatch compatible con Prometheus ya está implementado en el clúster, debe eliminarlo con el siguiente comando: ``` kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch ``` 1. Implemente el agente de CloudWatch con la configuración actualizada con uno de los siguientes comandos. Reemplace *MyCluster* y la *Región* para que concuerde con la configuración. Para un clúster de Amazon EKS con el tipo de lanzamiento de EC2, ingrese este comando. ``` kubectl apply -f prometheus-eks.yaml ``` Para un clúster de Amazon EKS con el tipo de lanzamiento de Fargate, ingrese este comando. ``` cat prometheus-eks-fargate.yaml \ | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \ | kubectl apply -f - ``` Para un clúster de Kubernetes, escriba este comando: ``` cat prometheus-k8s.yaml \ | sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \ | kubectl apply -f - ``` ## Visualización de las métricas de Redis OSS Prometheus En este tutorial se envían las siguientes métricas al espacio de nombres **ContainerInsights/Prometheus** en CloudWatch. 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, `Namespace` | | `redis_net_output_bytes_total` | ClusterName, `Namespace` | | `redis_expired_keys_total` | ClusterName, `Namespace` | | `redis_evicted_keys_total` | ClusterName, `Namespace` | | `redis_keyspace_hits_total` | ClusterName, `Namespace` | | `redis_keyspace_misses_total` | ClusterName, `Namespace` | | `redis_memory_used_bytes` | ClusterName, `Namespace` | | `redis_connected_clients` | ClusterName, `Namespace` | | `redis_commands_total` | ClusterName, `Namespace`, cmd | | `redis_db_keys` | ClusterName, `Namespace`, 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 REGION_NAME=your_metric_region_such_as_us-east-1 CLUSTER_NAME=your_k8s_cluster_name_here NAMESPACE=your_redis_service_namespace_here ``` 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" \ ``` # Conversión del tipo de métrica de Prometheus realizada por el agente de CloudWatch Las bibliotecas de cliente de Prometheus ofrecen cuatro tipos de métricas principales: + Contador + Calibre + Resumen + Histograma El agente de CloudWatch admite los tipos de métricas de contador, medición y resumen. El agente de CloudWatch descarta las métricas de Prometheus con el tipo de métrica de histograma no compatible. Para obtener más información, consulte [Registro de métricas de Prometheus descartadas](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics). **Métricas de medición** Una métrica de medición de Prometheus es una métrica que representa un único valor numérico que puede subir y bajar arbitrariamente. El agente de CloudWatch raspa las métricas de medición y envía estos valores directamente. **Métricas de contador** Una métrica de contador de Prometheus es una métrica acumulada que representa un contador monotónico en aumento cuyo valor sólo puede aumentar o reiniciarse a cero. El agente de CloudWatch calcula un delta desde el raspado anterior y envía el valor delta como valor de métrica en el evento de registro. Por lo tanto, el agente de CloudWatch comenzará a producir un evento de registro desde el segundo raspado y continuará con los raspados posteriores, si los hay. **Métricas de resumen** Una métrica de resumen de Prometheus es un tipo de métrica compleja que está representada por varios puntos de datos. Proporciona un recuento total de observaciones y una suma de todos los valores observados. Calcula cuantiles configurables a través de una ventana de tiempo variable. La suma y el recuento de una métrica de resumen son acumulativos, pero los cuantiles no lo son. El siguiente ejemplo muestra la desviación de los cuantiles. ``` # TYPE go_gc_duration_seconds summary go_gc_duration_seconds{quantile="0"} 7.123e-06 go_gc_duration_seconds{quantile="0.25"} 9.204e-06 go_gc_duration_seconds{quantile="0.5"} 1.1065e-05 go_gc_duration_seconds{quantile="0.75"} 2.8731e-05 go_gc_duration_seconds{quantile="1"} 0.003841496 go_gc_duration_seconds_sum 0.37630427 go_gc_duration_seconds_count 9774 ``` El agente de CloudWatch gestiona la suma y el recuento de una métrica de resumen de la misma manera que maneja las métricas de contador, como se describe en la sección anterior. El agente de CloudWatch conserva los valores del cuantil tal como se notifican originalmente. # Métricas de Prometheus que el agente de CloudWatch recopila El agente de CloudWatch compatible con Prometheus recopila automáticamente las métricas de varios servicios y cargas de trabajo. En las siguientes secciones se detallan las métricas que se recopilan de forma predeterminada. También puede configurar el agente para que recopile más métricas de otros servicios y métricas de Prometheus desde diferentes aplicaciones y servicios. Para obtener más información acerca de la recopilación de métricas adicionales, consulte [Configuración del agente de CloudWatch para Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config). Las métricas de Prometheus recopiladas de los clústeres de Amazon EKS y Kubernetes se encuentran en el espacio de nombres **ContainerInsights/Prometheus**. Las métricas de Prometheus que se recopilan de los clústeres de Amazon ECS se encuentran en el espacio de nombres **ECS/ContainerInsights/Prometheus**. **Topics** + [Métricas de Prometheus para App Mesh](#ContainerInsights-Prometheus-metrics-appmesh) + [Métricas de Prometheus para NGINX](#ContainerInsights-Prometheus-metrics-nginx) + [Métricas de Prometheus para Memcached](#ContainerInsights-Prometheus-metrics-memcached) + [Métricas de Prometheus para Java/JMX](#ContainerInsights-Prometheus-metrics-jmx) + [Métricas de Prometheus para HAProxy](#ContainerInsights-Prometheus-metrics-haproxy) ## Métricas de Prometheus para App Mesh Las siguientes métricas se recopilan automáticamente de App Mesh. **Métricas de Prometheus para App Mesh en clústeres de Amazon EKS y de Kubernetes** | Nombre de métrica | Dimensiones | | --- | --- | | `envoy_http_downstream_rq_total` | ClusterName, `Namespace` | | `envoy_http_downstream_rq_xx` | ClusterName, `Namespace` ClusterName, `Namespace`, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class | | `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `Namespace` | | `envoy_cluster_membership_healthy` | ClusterName, `Namespace` | | `envoy_cluster_membership_total` | ClusterName, `Namespace` | | `envoy_server_memory_heap_size` | ClusterName, `Namespace` | | `envoy_server_memory_allocated` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry_success` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `Namespace` | | `envoy_server_live` | ClusterName, `Namespace` | | `envoy_server_uptime` | ClusterName, `Namespace` | **Métricas de Prometheus para App Mesh en clústeres de Amazon ECS** | Nombre de métrica | Dimensiones | | --- | --- | | `envoy_http_downstream_rq_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_http_downstream_rq_xx` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_membership_healthy` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_membership_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_memory_heap_size` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_memory_allocated` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry_success` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_live` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_uptime` | ClusterName, `TaskDefinitionFamily` | | `envoy_http_downstream_rq_xx` | ClusterName, TaskDefinitionFamily, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class ClusterName, TaskDefinitionFamily, envoy\$1response\$1code\$1class | **nota** `TaskDefinitionFamily` es el espacio de nombres Kubernetes de la malla. El valor de `envoy_http_conn_manager_prefix` puede ser `ingress`, `egress` o `admin`. El valor de `envoy_response_code_class` puede ser `1` (corresponde a `1xx`), `2` corresponde a `2xx`), `3` corresponde a `3xx`), `4` corresponde a `4xx`) o `5` que corresponde a `5xx`). ## Métricas de Prometheus para NGINX Las siguientes métricas se recopilan automáticamente de NGINX en clústeres de Amazon EKS y de Kubernetes. | Nombre de métrica | Dimensiones | | --- | --- | | `nginx_ingress_controller_nginx_process_cpu_seconds_total` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_success` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_requests` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_nginx_process_connections` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_nginx_process_connections_total` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_nginx_process_resident_memory_bytes` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_config_last_reload_successful` | ClusterName, `Namespace`, Servicio | | `nginx_ingress_controller_requests` | ClusterName, `Namespace`, Servicio, estado | ## Métricas de Prometheus para Memcached Las siguientes métricas se recopilan automáticamente de Memcached en clústeres de Amazon EKS y de Kubernetes. | Nombre de métrica | Dimensiones | | --- | --- | | `memcached_current_items` | ClusterName, `Namespace`, Servicio | | `memcached_current_connections` | ClusterName, `Namespace`, Servicio | | `memcached_limit_bytes` | ClusterName, `Namespace`, Servicio | | `memcached_current_bytes` | ClusterName, `Namespace`, Servicio | | `memcached_written_bytes_total` | ClusterName, `Namespace`, Servicio | | `memcached_read_bytes_total` | ClusterName, `Namespace`, Servicio | | `memcached_items_evicted_total` | ClusterName, `Namespace`, Servicio | | `memcached_items_reclaimed_total` | ClusterName, `Namespace`, Servicio | | `memcached_commands_total` | ClusterName, `Namespace`, Servicio ClusterName, `Namespace`, Servicio, comando ClusterName, `Namespace`, Servicio, estado, comando | ## Métricas de Prometheus para Java/JMX **Métricas recopiladas en clústeres de Amazon EKS y de Kubernetes** En los clústeres de Amazon EKS y de Kubernetes, Información de contenedores puede recopilar las siguientes métricas de Prometheus predefinidas de Java Virtual Machine (JVM), Java y Tomcat (Catalina) mediante JMX Exporter. Para obtener más información, consulte [ prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) en Github. **Java/JMX en clústeres de Amazon EKS y de Kubernetes** | Nombre de métrica | Dimensiones | | --- | --- | | `jvm_classes_loaded` | `ClusterName`, `Namespace` | | `jvm_threads_current` | `ClusterName`, `Namespace` | | `jvm_threads_daemon` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_processcpuload` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `Namespace` | | `jvm_memory_bytes_used` | `ClusterName`, `Namespace`, área | | `jvm_memory_pool_bytes_used` | `ClusterName`, `Namespace`, grupo | **nota** Los valores de la dimensión `area` pueden ser `heap` o `nonheap`. Los valores de la dimensión `pool` pueden ser `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` o `Metaspace`. **TomCat/JMX en clústeres de Amazon EKS y de Kubernetes** Además de las métricas de Java/JMX de la tabla anterior, también se recopilan las siguientes métricas de la carga de trabajo de Tomcat. | Nombre de métrica | Dimensiones | | --- | --- | | `catalina_manager_activesessions` | `ClusterName`, `Namespace` | | `catalina_manager_rejectedsessions` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `Namespace` | **Java/JMX en clústeres de Amazon ECS** | Nombre de métrica | Dimensiones | | --- | --- | | `jvm_classes_loaded` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_threads_current` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_threads_daemon` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_processcpuload` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_memory_bytes_used` | `ClusterName`, TaskDefinitionFamily, área | | `jvm_memory_pool_bytes_used` | `ClusterName`, TaskDefinitionFamily, grupo | **nota** Los valores de la dimensión `area` pueden ser `heap` o `nonheap`. Los valores de la dimensión `pool` pueden ser `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` o `Metaspace`. **Tomcat/JMX en clústeres de Amazon ECS** Además de las métricas de Java/JMX de la tabla anterior, también se recopilan las siguientes métricas de la carga de trabajo de Tomcat en clústeres de Amazon ECS. | Nombre de métrica | Dimensiones | | --- | --- | | `catalina_manager_activesessions` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_manager_rejectedsessions` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `TaskDefinitionFamily` | ## Métricas de Prometheus para HAProxy Las siguientes métricas se recopilan automáticamente de HAProxy en clústeres de Amazon EKS y de Kubernetes. Las métricas recopiladas dependen de la versión de HAProxy Ingress que esté utilizando. Para obtener más información sobre HAProxy Ingress y sus versiones, consulte [haproxy-ingress](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress). | Nombre de métrica | Dimensiones | Disponibilidad | | --- | --- | --- | | `haproxy_backend_bytes_in_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_backend_bytes_out_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_backend_connection_errors_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_backend_connections_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_backend_current_sessions` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_backend_http_responses_total` | `ClusterName`, `Namespace`, Servicio, código, backend | Todas las versiones de HAProxy Ingress | | `haproxy_backend_status` | `ClusterName`, `Namespace`, Servicio | Sólo en versiones de HAProxy Ingress 0.10 o posteriores | | `haproxy_backend_up` | `ClusterName`, `Namespace`, Servicio | Sólo en versiones de HAProxy Ingress anteriores a 0.10 | | `haproxy_frontend_bytes_in_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_bytes_out_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_connections_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_current_sessions` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_http_requests_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_http_responses_total` | `ClusterName`,`Namespace`, Servicio, código, frontend | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_request_errors_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | | `haproxy_frontend_requests_denied_total` | `ClusterName`, `Namespace`, Servicio | Todas las versiones de HAProxy Ingress | **nota** Los valores de la dimensión `code` pueden ser `1xx`, `2xx`, `3xx`, `4xx`, `5xx` o `other`. Los valores de la dimensión `backend` pueden ser: `http-default-backend`, `http-shared-backend` o `httpsback-shared-backend` para HAProxy Ingress versión 0.0.27 o anteriores. `_default_backend` para las versiones de HAProxy Ingress posteriores a 0.0.27. Los valores de la dimensión `frontend` pueden ser: `httpfront-default-backend`, `httpfront-shared-frontend` o `httpfronts` para HAProxy Ingress versión 0.0.27 o anteriores. `_front_http` o `_front_https` para las versiones de HAProxy Ingress posteriores a 0.0.27. # Visualización de las métricas de Prometheus Puede supervisión todas las métricas de Prometheus e crear alarmas sobre ellas, incluidas las que se seleccionaron y se agregaron previamente desde App Mesh, NGINX, Java/JMX, Memcached y HAProxy, así como de cualquier otro exportador de Prometheus que se haya agregado y configurado manualmente . Para obtener más información acerca de cómo recopilar métricas de otros exportadores de Prometheus, 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). En la consola de CloudWatch, Información de contenedores proporciona los siguientes informes preconstruidos: + Para los clústeres de Amazon EKS y de Kubernetes, hay informes preconstruidos para App Mesh, NGINX, HAPROXY, Memcached y Java/JMX. + Para los clústeres de Amazon ECS, hay informes preconstruidos para App Mesh y Java/JMX. Información de contenedores también proporciona paneles personalizados para cada una de las cargas de trabajo de las que Información de contenedores recopila métricas seleccionadas. Puede descargar estos paneles de GitHub **Para ver todas las métricas de Prometheus** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, seleccione **Métricas**. 1. En la lista de espacios de nombres, elija **ContainerInsights/Prometheus** o **ECS/ContainerInsights/Prometheus**. 1. Elija uno de los conjuntos de dimensiones de la siguiente lista. A continuación, active la casilla situada junto a las métricas que desee ver. **Para ver los informes prediseñados de las métricas de Prometheus** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, elija **Performance monitoring** (Supervisión del rendimiento). 1. En el cuadro desplegable situado cerca de la parte superior de la página, elija cualquiera de las opciones Prometheus. En el otro cuadro desplegable, elija el clúster que desee ver También se han incluido paneles personalizados para NGINX, App Mesh, Memcached, HAProxy y Java/JMX. **Para utilizar un panel personalizado proporcionado por Amazon** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, elija **Dashboards (Paneles)**. 1. Elija **Crear un panel**. Escriba el nombre del nuevo panel y elija **Crear un panel**. 1. En **Añadir a este panel**, elija **Cancelar**. 1. Elija **Actions (Acciones)**, **View/edit source (Ver/editar código fuente)**. 1. Descargue uno de los siguientes archivos JSON: + [ Origen de paneles personalizados para NGINX en Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json). + [ App Mesh custom dashboard source on Github (Fuente de paneles personalizados de App Mesh en Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json). + [ Origen de paneles personalizados de Memcached en Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json) + [ Origen de paneles personalizados de HAProxy-Ingress en Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json) + [ Origen de paneles personalizados para Java/JMX en Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.json). 1. Abra el archivo JSON que descargó con un editor de texto y realice los siguientes cambios: + Reemplace todas las cadenas `{{YOUR_CLUSTER_NAME}}` por el nombre exacto del clúster. Tenga cuidado de no agregar espacios en blanco antes o después del texto. + Reemplace todas las cadenas `{{YOUR_REGION}}` con la Región de AWS en la que se está ejecutando el clúster. Por ejemplo, en **us-west-1** asegúrese de no agregar espacios en blanco antes o después del texto. + Reemplace todas las cadenas `{{YOUR_NAMESPACE}}` por el espacio de nombres exacto de la carga de trabajo. + Reemplace todas las cadenas `{{YOUR_SERVICE_NAME}}` por el nombre exacto del servicio de la carga de trabajo. Por ejemplo: ., **haproxy-haproxy-ingress-controller-metrics** 1. Copie todo el blob JSON y péguelo en el cuadro de texto de la consola de CloudWatch de manera que sustituya el texto del cuadro. 1. Elija **Actualizar** y **Guardar el panel**. # Solución de problemas de las métricas de Prometheus Esta sección le ayudará a solucionar problemas relacionados con la configuración de las métricas de Prometheus. **Topics** + [Solución de problemas de las métricas de Prometheus en Amazon ECS](ContainerInsights-Prometheus-troubleshooting-ECS.md) + [Solución de problemas de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes](ContainerInsights-Prometheus-troubleshooting-EKS.md) # Solución de problemas de las métricas de Prometheus en Amazon ECS Esta sección le ayudará a solucionar problemas relacionados con la configuración de las métricas de Prometheus en clústeres de Amazon ECS. ## No se pueden ver las métricas de Prometheus que se enviaron a los CloudWatch Logs Las métricas de Prometheus se deberían capturar como eventos de registro en el grupo de registros **/aws/containerInsights/nombre-del-clúster/Prometheus**. Si no se crea el grupo de registros o las métricas de Prometheus no se envían al grupo de registros, primero se deberá verificar si el agente de CloudWatch ha detectado correctamente los destinos de Prometheus. A continuación, verifique el grupo de seguridad y la configuración de permisos del agente de CloudWatch. Los siguientes pasos lo guiarán para realizar la depuración. **Paso 1: habilite el modo de depuración del agente de CloudWatch** Primero, cambie el agente de CloudWatch al modo de depuración al agregar los siguientes renglones en negrita al archivo de plantilla de CloudFormation, `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` o `cwagent-ecs-prometheus-metric-for-awsvpc.yaml`. A continuación, guarde el archivo. ``` cwagentconfig.json: | { "agent": { "debug": true }, "logs": { "metrics_collected": { ``` Cree un nuevo conjunto de cambios de CloudFormation con respecto a la pila existente. Establezca otros parámetros en el conjunto de cambios a los mismos valores que tiene en la pila de CloudFormation. El siguiente ejemplo es para un agente de CloudWatch instalado en un clúster de Amazon ECS que utiliza el tipo de lanzamiento de EC2 y el modo de red puente. ``` 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 NEW_CHANGESET_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 $NEW_CHANGESET_NAME ``` Diríjase a la consola de CloudFormation para revisar el nuevo conjunto de cambios, `$NEW_CHANGESET_NAME`. Debe haber 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 your_service_name_here \ --region $AWS_REGION ``` Espere aproximadamente 10 segundos y, a continuación, ingrese el siguiente comando. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service your_service_name_here \ --region $AWS_REGION ``` **Paso 2: verifique los registros de detección del servicio de ECS** La definición de tarea ECS del agente de CloudWatch habilita los registros de forma predeterminada en la siguiente sección. Los registros se envían a CloudWatch Logs en el grupo de registros **/ecs/ecs-cwagent-prometheus**. ``` LogConfiguration: LogDriver: awslogs Options: awslogs-create-group: 'True' awslogs-group: "/ecs/ecs-cwagent-prometheus" awslogs-region: !Ref AWS::Region awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc' ``` Filtre los registros mediante la cadena `ECS_SD_Stats` para obtener las métricas relacionadas con la detección de servicios de ECS, tal y como se muestra en el siguiente ejemplo. ``` 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms ``` El significado de cada métrica para un ciclo de detección de servicios de ECS particular es el siguiente: + **AWSCLI\$1DescribeContainerInstances**: el número de llamadas a la API `ECS::DescribeContainerInstances` realizadas. + **AWSCLI\$1DescribeInstancesRequest**: el número de llamadas a la API `ECS::DescribeInstancesRequest` realizadas. + **AWSCLI\$1DescribetaskDefinition**: el número de llamadas a la API `ECS::DescribeTaskDefinition` realizadas. + **AWSCLI\$1DescribeTasks**: el número de llamadas a la API `ECS::DescribeTasks` realizadas. + **AWSCLI\$1ListTasks**: el número de llamadas a la API `ECS::ListTasks` realizadas. + **ExporterDiscoveredTargetCount**: el número de destinos de Prometheus que se detectaron y exportaron correctamente al archivo de resultados de destino dentro del contenedor. + **LRUCache\$1Get\$1EC2MetaData**: el número de veces que se recuperaron los metadatos de instancias de contenedor de la caché. + **LRUCache\$1Get\$1TaskDefinition**: el número de veces que los metadatos de definición de tareas de ECS se recuperaron de la caché. + **LRUCache\$1Size\$1ContainerInstance**: el número de metadatos de la instancia de contenedor únicos almacenados en caché en la memoria. + **LRUCache\$1Size\$1TaskDefinition**: el número de definiciones de tareas ECS únicas almacenadas en caché en la memoria. + **Latencia**: cuánto tiempo tarda el ciclo de detección de servicios. Verifique el valor de `ExporterDiscoveredTargetCount` para ver si los destinos de Prometheus detectados concuerdan con las expectativas. De lo contrario, las razones posibles son las siguientes: + Es posible que la configuración de la detección de servicios de ECS no concuerde con la configuración de la aplicación. Para la detección de servicios basada en etiquetas docker, es posible que los contenedores de destino no tengan la etiqueta docker necesaria configurada en el agente de CloudWatch para detectarlos automáticamente. Para la detección de servicios basado en expresiones regulares ARN de la definición de tarea de ECS, es posible que la configuración de las expresiones regulares en el agente de CloudWatch no coincida con la definición de tarea de la aplicación. + Es posible que el rol de tarea de ECS del agente de CloudWatch no tenga permiso para recuperar los metadatos de las tareas de ECS. Verifique que el agente de CloudWatch ha obtenido los siguientes permisos de sólo lectura: + `ec2:DescribeInstances` + `ecs:ListTasks` + `ecs:DescribeContainerInstances` + `ecs:DescribeTasks` + `ecs:DescribeTaskDefinition` **Paso 3: verifique la conexión de red y la política de rol de tareas de ECS** Si todavía no hay eventos de registro enviados al grupo de registro de CloudWatch Logs de destino aunque el valor de `Exporter_DiscoveredTargetCount` indica que hay destinos de Prometheus detectados, esto podría deberse a una de las siguientes causas: + Es posible que el agente de CloudWatch no pueda conectarse a los puertos de destino de Prometheus. Verifique la configuración del grupo de seguridad detrás del agente de CloudWatch. La IP privada debe permitir que el agente de CloudWatch se conecte a los puertos del exportador de Prometheus. + Es posible que el rol de tarea de ECS del agente de CloudWatch no cuente con la política administrada **CloudWatchAgentServerPolicy**. Se necesita contar con esta política para que el rol de tarea de ECS del agente de CloudWatch pueda enviar las métricas de Prometheus como eventos de registro. Si utilizó la plantilla de muestra de CloudFormation para crear los roles de IAM de forma automática, tanto el rol de tarea de ECS como el rol de ejecución de ECS se otorgan con el privilegio mínimo para la supervisión de Prometheus. # Solución de problemas de métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes Esta sección proporciona ayuda para solucionar problemas relacionados con la configuración de las métricas de Prometheus en clústeres de Amazon EKS y de Kubernetes. ## Pasos generales de solución de problemas en Amazon EKS Ingrese el siguiente comando para confirmar que el agente de CloudWatch se está ejecutando. ``` kubectl get pod -n amazon-cloudwatch ``` En la salida, debería aparecer una fila con el valor `cwagent-prometheus-id` en la columna `NAME` y el valor `Running` en `STATUS column.` Para obtener más información sobre el pod en ejecución, escriba el siguiente comando. Sustituya *pod-name* por el nombre completo del pod que debe comenzar por `cw-agent-prometheus`. ``` kubectl describe pod pod-name -n amazon-cloudwatch ``` Si Información de contenedores de CloudWatch está instalado, puede utilizar Información de registros de CloudWatch para consultar los registros del agente de CloudWatch que recopila las métricas de Prometheus. **Para consultar los registros de la aplicación** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, elija **Información de registros de CloudWatch**. 1. Seleccione el grupo de registros de la aplicación, **/aws/containerinsights/*nombre-del-clúster*/application** 1. Sustituya la expresión de la consulta de búsqueda por la siguiente consulta y elija **Ejecutar la consulta**. ``` fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log | filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus ``` También se puede confirmar que las métricas y los metadatos de Prometheus se están capturando como eventos de CloudWatch Logs. **Para confirmar que los datos de Prometheus se están ingiriendo** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, elija **Información de registros de CloudWatch**. 1. Seleccione **/aws/containerinsights/*nombre-del-clúster*/prometheus** 1. Sustituya la expresión de la consulta de búsqueda por la siguiente consulta y elija **Ejecutar la consulta**. ``` fields @timestamp, @message | sort @timestamp desc | limit 20 ``` ## Registro de métricas de Prometheus descartadas Esta versión no recopila métricas de Prometheus de tipo histograma. Puede utilizar el agente de CloudWatch para verificar si se está descartando alguna métrica de Prometheus porque son de tipo histograma. También puede registrar una lista de las primeras 500 métricas de Prometheus descartadas que no se envían a CloudWatch porque son de tipo histograma. Para comprobar si se está descartando alguna métrica, ejecute el siguiente comando: ``` kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1 ``` Si se está descartando alguna métrica, aparecerán las siguientes líneas en el archivo `/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log`. ``` I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported. I! Please enable CWAgent debug mode to view the first 500 dropped metrics ``` Si ve esas líneas y desea saber qué métricas se están descartando, siga estos pasos. **Para registrar una lista de métricas de Prometheus descartadas** 1. Cambie el agente de CloudWatch al modo de depuración al agregar las siguientes líneas en negrita al archivo `prometheus-eks.yaml` o `prometheus-k8s.yaml`, y guarde el archivo. ``` { "agent": { "debug": true }, ``` Esta sección del archivo debería aparecer así: ``` cwagentconfig.json: | { "agent": { "debug": true }, "logs": { "metrics_collected": { ``` 1. Vuelva a instalar el agente de CloudWatch para habilitar el modo de depuración con los siguientes comandos: ``` kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch kubectl apply -f prometheus.yaml ``` Las métricas descartadas se registran en el pod del agente de CloudWatch. 1. Para recuperar los registros del pod del agente de CloudWatch, ingrese el siguiente comando: ``` kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1 ``` O bien, si tiene instalado el registro Fluentd de Información de contenedores, los registros también se guardan en el grupo de registro de registros de CloudWatch **/aws/containerinsights/*cluster\$1name*/application**. Para consultar estos registros, siga los pasos que se indican en [Pasos generales de solución de problemas en Amazon EKS](#ContainerInsights-Prometheus-troubleshooting-general). ## ¿Dónde se capturan las métricas de Prometheus como eventos de registro de CloudWatch Logs? El agente de CloudWatch crea un flujo de registros en la configuración de cada trabajo de raspado de Prometheus. Por ejemplo, en los archivos `prometheus-eks.yaml` y `prometheus-k8s.yaml`, la línea `job_name: 'kubernetes-pod-appmesh-envoy'` raspa las métricas de App Mesh. El destino de Prometheus está definido como `kubernetes-pod-appmesh-envoy`. Por tanto, todas las métricas de Prometheus de App Mesh se ingieren como eventos de CloudWatch Logs en el flujo de registro **kubernetes-pod-appmesh-envoy** bajo el grupo de registros **/aws/containerinsights/cluster-name/Prometheus**. ## No se pueden ver las métricas de Amazon EKS o de Kubernetes Prometheus en las métricas de CloudWatch En primer lugar, asegúrese de que las métricas de Prometheus se están ingiriendo como eventos de registro en el grupo de registros **/aws/containerInsights/nombre-del-clúster/Prometheus**. Utilice la información de [¿Dónde se capturan las métricas de Prometheus como eventos de registro de CloudWatch Logs?](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested) para que le ayude a comprobar el flujo de registro de destino. Si el flujo de registro no se ha creado o no hay nuevos eventos de registro en el flujo, compruebe lo siguiente: + Compruebe que los puntos de enlace del exportador de métricas de Prometheus están configurados correctamente. + Verifique que las configuraciones de raspado de Prometheus incluidas en la sección `config map: cwagent-prometheus` del archivo YAML del agente de CloudWatch sean correctas. La configuración debe ser la misma que la de un archivo de configuración de Prometheus. Para obtener más información, consulte [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) en la documentación de Prometheus. Si las métricas de Prometheus se ingieren correctamente como eventos de registro, compruebe que la configuración de formato de métrica integrado se ha agregado a los eventos de registro para generar las métricas de CloudWatch. ``` "CloudWatchMetrics":[ { "Metrics":[ { "Name":"envoy_http_downstream_cx_destroy_remote_active_rq" } ], "Dimensions":[ [ "ClusterName", "Namespace" ] ], "Namespace":"ContainerInsights/Prometheus" } ], ``` Para obtener más información sobre el formato de métrica integrado, consulte [Especificación: Formato de métricas integradas](CloudWatch_Embedded_Metric_Format_Specification.md). Si no hay ningún formato de métrica integrada en los eventos de registro, verifique que la sección `metric_declaration` esté configurada correctamente en la sección `config map: prometheus-cwagentconfig` del archivo YAML de instalación del agente de CloudWatch. Para obtener más información, 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).