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