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