# Configuración de la recopilación de métricas de Prometheus en instancias de Amazon EC2 En las siguientes secciones se explica cómo se instala el agente CloudWatch con supervisión de Prometheus en instancias EC2 y cómo se configura el agente para que elimine destinos adicionales. También proporciona tutoriales para configurar cargas de trabajo de muestra para usar pruebas con supervisión de Prometheus. Las instancias de Windows y Linux son compatibles. Para obtener información sobre los sistemas operativos compatibles con el agente de CloudWatch, consulte [Recopile las métricas, registros y seguimientos con el agente de CloudWatch](Install-CloudWatch-Agent.md) **Requisitos del grupo de seguridad de la VPC** Si utiliza una VPC, se aplican los siguientes requisitos. + 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 extraer 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 una IP privada. **Topics** + [Paso 1: Instale el agente de CloudWatch](#CloudWatch-Agent-PrometheusEC2-install) + [Paso 2: Raspe las fuentes Prometheus e importe las métricas](#CloudWatch-Agent-PrometheusEC2-configure) + [Ejemplo: Configure las cargas de trabajo de ejemplo de Java/JMX para las pruebas métricas de Prometheus](#CloudWatch-Agent-Prometheus-Java) ## Paso 1: Instale el agente de CloudWatch El primer paso consiste en instalar el agente de CloudWatch en la instancia EC2. Para obtener instrucciones, consulte [Instalación del agente de CloudWatch](install-CloudWatch-Agent-on-EC2-Instance.md). ## Paso 2: Raspe las fuentes Prometheus e importe las 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 la configuración estándar de Prometheus que se describe en [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) de la documentación de Prometheus. El otro es para la configuración del agente de CloudWatch. ### 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. Un archivo de configuración de ejemplo contiene las siguientes líneas de configuración global: ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus.yaml global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: MY_JOB sample_limit: 10000 file_sd_configs: - files: ["C:\\ProgramData\\Amazon\\AmazonCloudWatchAgent\\prometheus_sd_1.yaml", "C:\\ProgramData\\Amazon\\AmazonCloudWatchAgent\\prometheus_sd_2.yaml"] ``` La sección `global` especifica los parámetros que son válidos en todos los contextos de configuración. También sirven como valores predeterminados para otras secciones de configuración. Contiene los siguientes parámetros: + `scrape_interval`: define la frecuencia con la que se deben raspar los objetivos. + `scrape_timeout`: define cuánto tiempo debe esperar antes de que se agote el tiempo de espera de una solicitud de raspado. La sección `scrape_configs` especifica un conjunto de objetivos y parámetros que definen cómo se deben raspar. Contiene los siguientes parámetros: + `job_name`: el nombre del trabajo que se ha asignado a las métricas raspadas de forma predeterminada. + `sample_limit`: límite por raspado en el número de muestras raspadas que se aceptarán. + `file_sd_configs`: lista de configuraciones de detección de servicios de archivos. Lee un conjunto de archivos que contienen una lista de cero o más configuraciones estáticas. La sección `file_sd_configs` contiene un parámetro `files` que define patrones para los archivos de los que se extraen los grupos de destino. El agente de CloudWatch admite los siguientes tipos de configuración de detección de servicios. **`static_config`** Permite especificar una lista de destinos y un conjunto de etiquetas comunes para ellos. Es la forma canónica de especificar objetivos estáticos en una configuración de raspado. A continuación, se muestra una configuración estática de ejemplo para extraer métricas de Prometheus de un host local. Las métricas también se pueden extraer de otros servidores si el puerto Prometheus está abierto al servidor donde se ejecuta el agente. ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus_sd_1.yaml - targets: - 127.0.0.1:9404 labels: key1: value1 key2: value2 ``` Este ejemplo contiene los siguientes parámetros: + `targets`: los objetivos que la configuración estática ha raspado. + `labels`: etiquetas asignadas a todas las métricas que se raspan de los destinos. **`ec2_sd_config`** Permite recuperar destinos de raspado de instancias de Amazon EC2. A continuación, se muestra un ejemplo `ec2_sd_config` para raspar las métricas de Prometheus de una lista de instancias EC2. Los puertos Prometheus de estas instancias tienen que abrirse al servidor donde se ejecuta el agente de CloudWatch. El rol de IAM para la instancia EC2 en la que se ejecuta el agente de CloudWatch debe incluir el permiso `ec2:DescribeInstance`. Por ejemplo, puede adjuntar la política administrada **AmazonEC2ReadOnlyAccess** a la instancia que ejecuta el agente de CloudWatch. ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus.yaml global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: MY_JOB sample_limit: 10000 ec2_sd_configs: - region: us-east-1 port: 9404 filters: - name: instance-id values: - i-98765432109876543 - i-12345678901234567 ``` Este ejemplo contiene los siguientes parámetros: + `region`: la región de AWS donde se encuentra la instancia EC2 de destino. Si deja este campo en blanco, se usará la región de los metadatos de instancia. + `port`: el puerto desde el que se raspan las métricas. + `filters`: filtros opcionales que se utilizarán para filtrar la lista de instancias. Este ejemplo se filtra en función de los ID de las instancias EC2. Para obtener más criterios por los que se puede filtrar, consulte [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html). ### Configuración del agente de CloudWatch para Prometheus El archivo de configuración del agente de CloudWatch incluye secciones `prometheus` en `logs` y `metrics_collected`. Incluye los siguientes parámetros. + **cluster\_name**: especifica el nombre del clúster que se va a agregar como etiqueta en el evento de registro. Este campo es opcional. + **log\_group\_name**: especifica el nombre del grupo de registros de las métricas de Prometheus raspadas. + **prometheus\_config\_path**: especifica la ruta del archivo de configuración de descubrimiento de Prometheus. + **emf\_processor**: especifica la configuración del procesador de formato de métrica integrada. Para obtener más información sobre el formato de métrica integrado, consulte [Incrustar métricas en los registros](CloudWatch_Embedded_Metric_Format.md). La sección `emf_processor` contiene los siguientes parámetros: + **metric\_declaration\_dedup**: se establece en VERDADERO, la función de desduplicación para las métricas de formato de métrica incrustada está habilitada. + **metric\_namespace**: especifica el espacio de nombres de la métrica para las métricas emitidas de CloudWatch. + **metric\_unit**: especifica el nombre de métrica: mapa de unidades métricas. Para obtener más información acerca de las unidades métricas compatibles consulte [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html). + **metric\_declaration**: 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: + `source_labels` especifica el valor de las etiquetas que se comprueban con `label_matcher`. + `label_matcher` es una expresión regular que verifica el valor de las etiquetas que aparecen en `source_labels`. Las métricas que coinciden se habilitan para incorporarse al formato de métrica integrada que se envía a CloudWatch. + `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. A continuación se muestra un ejemplo de configuración del agente de CloudWatch para Prometheus. ``` { "logs":{ "metrics_collected":{ "prometheus":{ "cluster_name":"prometheus-cluster", "log_group_name":"Prometheus", "prometheus_config_path":"C:\\ProgramData\\Amazon\\AmazonCloudWatchAgent\\prometheus.yaml", "emf_processor":{ "metric_declaration_dedup":true, "metric_namespace":"CWAgent-Prometheus", "metric_unit":{ "jvm_threads_current": "Count", "jvm_gc_collection_seconds_sum": "Milliseconds" }, "metric_declaration":[ { "source_labels":[ "job", "key2" ], "label_matcher":"MY_JOB;^value2", "dimensions":[ [ "key1", "key2" ], [ "key2" ] ], "metric_selectors":[ "^jvm_threads_current$", "^jvm_gc_collection_seconds_sum$" ] } ] } } } } } ``` En el ejemplo anterior se configura una sección de formato de métrica integrada para que se envíe como evento de registro si se cumplen las siguientes condiciones: + El valor de la etiqueta `job` es `MY_JOB` + El valor de la etiqueta `key2` es `value2` + Las métricas de Prometheus `jvm_threads_current` y `jvm_gc_collection_seconds_sum` contienen las etiquetas `job` y `key2`. El evento de registro que se envía incluye la siguiente sección resaltada: ``` { "CloudWatchMetrics": [ { "Metrics": [ { "Unit": "Count", "Name": "jvm_threads_current" }, { "Unit": "Milliseconds", "Name": "jvm_gc_collection_seconds_sum" } ], "Dimensions": [ [ "key1", "key2" ], [ "key2" ] ], "Namespace": "CWAgent-Prometheus" } ], "ClusterName": "prometheus-cluster", "InstanceId": "i-0e45bd06f196096c8", "Timestamp": "1607966368109", "Version": "0", "host": "EC2AMAZ-PDDOIUM", "instance": "127.0.0.1:9404", "jvm_threads_current": 2, "jvm_gc_collection_seconds_sum": 0.006000000000000002, "prom_metric_type": "gauge", ... } ``` ## Ejemplo: Configure las cargas de trabajo de ejemplo de Java/JMX para las pruebas métricas de Prometheus 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\_exporter](https://github.com/prometheus/jmx_exporter). El agente de CloudWatch recolecta métricas predefinidas de Prometheus de la máquina virtual de Java (JVM), Hjava y de Tomcat (Catalina) de un JMX Exporter en instancias EC2. ### Paso 1: Instale el agente de CloudWatch El primer paso consiste en instalar el agente de CloudWatch en la instancia EC2. Para obtener instrucciones, consulte [Instalación del agente de CloudWatch](install-CloudWatch-Agent-on-EC2-Instance.md). ### Paso 2: Comience la carga de trabajo de Java/JMX El siguiente paso es comenzar la carga de trabajo de Java/JMX. Primero, descargue el archivo jar más reciente de JMX exporter desde la siguiente ubicación: [prometheus/jmx\_exporter](https://github.com/prometheus/jmx_exporter). **Use el jar para la aplicación de muestra** Los comandos de ejemplo de las siguientes secciones utilizan `SampleJavaApplication-1.0-SNAPSHOT.jar` como el archivo jar. Reemplace estas partes de los comandos con el jar para la aplicación. #### Prepare la configuración de JMX exporter El archivo `config.yaml` es el archivo de configuración de JMX Exporter. Para obtener más información, consulte [Configuration](https://github.com/prometheus/jmx_exporter#Configuration) (Configuración) en la documentación de JMX exporter. 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: ".*" ``` #### Inicie la aplicación Java con el exportador de Prometheus Inicie la aplicación de ejemplo Esto emitirá métricas de Prometheus al puerto 9404. Asegúrese de sustituir el punto de entrada `com.gubupt.sample.app.App` con la información correcta para la aplicación java de muestra. En Linux ingrese el siguiente comando: ``` $ nohup java -javaagent:./jmx_prometheus_javaagent-0.14.0.jar=9404:./config.yaml -cp ./SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App & ``` En Windows ingrese el siguiente comando: ``` PS C:\> java -javaagent:.\jmx_prometheus_javaagent-0.14.0.jar=9404:.\config.yaml -cp .\SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App ``` #### Verifique la emisión de métricas de Prometheus Verifique que se estén emitiendo métricas de Prometheus. En Linux ingrese el siguiente comando: ``` $ curl localhost:9404 ``` En Windows ingrese el siguiente comando: ``` PS C:\> curl http://localhost:9404 ``` Salida de ejemplo en Linux: ``` StatusCode : 200 StatusDescription : OK Content : # HELP jvm_classes_loaded The number of classes that are currently loaded in the JVM # TYPE jvm_classes_loaded gauge jvm_classes_loaded 2526.0 # HELP jvm_classes_loaded_total The total number of class... RawContent : HTTP/1.1 200 OK Content-Length: 71908 Content-Type: text/plain; version=0.0.4; charset=utf-8 Date: Fri, 18 Dec 2020 16:38:10 GMT # HELP jvm_classes_loaded The number of classes that are currentl... Forms : {} Headers : {[Content-Length, 71908], [Content-Type, text/plain; version=0.0.4; charset=utf-8], [Date, Fri, 18 Dec 2020 16:38:10 GMT]} Images : {} InputFields : {} Links : {} ParsedHtml : System.__ComObject RawContentLength : 71908 ``` ### Paso 3: Configure el agente de CloudWatch para raspar las métricas de Prometheus A continuación, configure la configuración de raspado de Prometheus en el archivo de configuración del agente CloudWatch. **Para establecer la configuración de raspado de Prometheus para el ejemplo de Java/JMX** 1. Establezca la configuración de `file_sd_config` y `static_config`. En Linux ingrese el siguiente comando: ``` $ cat /opt/aws/amazon-cloudwatch-agent/var/prometheus.yaml global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: jmx sample_limit: 10000 file_sd_configs: - files: [ "/opt/aws/amazon-cloudwatch-agent/var/prometheus_file_sd.yaml" ] ``` En Windows ingrese el siguiente comando: ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus.yaml global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: jmx sample_limit: 10000 file_sd_configs: - files: [ "C:\\ProgramData\\Amazon\\AmazonCloudWatchAgent\\prometheus_file_sd.yaml" ] ``` 1. Establezca la configuración de los objetivos de raspado. En Linux ingrese el siguiente comando: ``` $ cat /opt/aws/amazon-cloudwatch-agent/var/prometheus_file_sd.yaml - targets: - 127.0.0.1:9404 labels: application: sample_java_app os: linux ``` En Windows ingrese el siguiente comando: ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus_file_sd.yaml - targets: - 127.0.0.1:9404 labels: application: sample_java_app os: windows ``` 1. Establezca la configuración de raspado de Prometheus mediante `ec2_sc_config`. Reemplace {{su-ec2-instance-id}} con el ID de instancia EC2 correcto. En Linux ingrese el siguiente comando: ``` $ cat .\prometheus.yaml global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: jmx sample_limit: 10000 ec2_sd_configs: - region: us-east-1 port: 9404 filters: - name: instance-id values: - {{your-ec2-instance-id}} ``` En Windows ingrese el siguiente comando: ``` PS C:\ProgramData\Amazon\AmazonCloudWatchAgent> cat prometheus_file_sd.yaml - targets: - 127.0.0.1:9404 labels: application: sample_java_app os: windows ``` 1. Establezca la configuración del agente de CloudWatch. En primer lugar, vaya al directorio correcto. En Linux, es `/opt/aws/amazon-cloudwatch-agent/var/cwagent-config.json`. En Windows, es `C:\ProgramData\Amazon\AmazonCloudWatchAgent\cwagent-config.json`. La siguiente es una configuración de ejemplo con las métricas definidas de Java/JHX Prometheus. Asegúrese de reemplazar {{path-to-Prometheus-Scrape-Configuration-file}} con la ruta correcta. ``` { "agent": { "region": "us-east-1" }, "logs": { "metrics_collected": { "prometheus": { "cluster_name": "my-cluster", "log_group_name": "prometheus-test", "prometheus_config_path": "{{path-to-Prometheus-Scrape-Configuration-file}}", "emf_processor": { "metric_declaration_dedup": true, "metric_namespace": "PrometheusTest", "metric_unit":{ "jvm_threads_current": "Count", "jvm_classes_loaded": "Count", "java_lang_operatingsystem_freephysicalmemorysize": "Bytes", "catalina_manager_activesessions": "Count", "jvm_gc_collection_seconds_sum": "Seconds", "catalina_globalrequestprocessor_bytesreceived": "Bytes", "jvm_memory_bytes_used": "Bytes", "jvm_memory_pool_bytes_used": "Bytes" }, "metric_declaration": [ { "source_labels": ["job"], "label_matcher": "^jmx$", "dimensions": [["instance"]], "metric_selectors": [ "^jvm_threads_current$", "^jvm_classes_loaded$", "^java_lang_operatingsystem_freephysicalmemorysize$", "^catalina_manager_activesessions$", "^jvm_gc_collection_seconds_sum$", "^catalina_globalrequestprocessor_bytesreceived$" ] }, { "source_labels": ["job"], "label_matcher": "^jmx$", "dimensions": [["area"]], "metric_selectors": [ "^jvm_memory_bytes_used$" ] }, { "source_labels": ["job"], "label_matcher": "^jmx$", "dimensions": [["pool"]], "metric_selectors": [ "^jvm_memory_pool_bytes_used$" ] } ] } } }, "force_flush_interval": 5 } } ``` 1. Para reiniciar el agente de CloudWatch, introduzca uno de los siguientes comandos. En Linux ingrese el siguiente comando: ``` sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c file:/opt/aws/amazon-cloudwatch-agent/var/cwagent-config.json ``` En Windows ingrese el siguiente comando: ``` & "C:\Program Files\Amazon\AmazonCloudWatchAgent\amazon-cloudwatch-agent-ctl.ps1" -a fetch-config -m ec2 -s -c file:C:\ProgramData\Amazon\AmazonCloudWatchAgent\cwagent-config.json ``` ### Visualización de las métricas y los registros de Prometheus Ahora puede ver las métricas de Java/JMX que se están recopilando. **Para visualizar las métricas de la carga de trabajo de ejemplo de Java/JMX** 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 **PrometheusTest** 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 **prometheus-test**.