# (Opcional) Configurar workloads de exemplo do Amazon EKS em contêineres para teste de métrica do Prometheus
Para testar o suporte para métricas do Prometheus no CloudWatch Container Insights, você pode configurar uma ou mais das seguintes workloads em contêineres. O atendente do CloudWatch com suporte ao Prometheus coleta automaticamente métricas de cada uma dessas workloads. Para visualizar as métricas coletadas por padrão, consulte [Métricas do Prometheus coletadas pelo atendente do CloudWatch](ContainerInsights-Prometheus-metrics.md).
Antes de instalar qualquer uma dessas cargas de trabalho, instale o Helm 3.x inserindo os comandos a seguir:
```
brew install helm
```
Para obter mais informações, consulte [Helm](https://helm.sh).
**Topics**
+ [Configurar amostra de workload AWS App Mesh para o Amazon EKS e o Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [Configurar o NGINX com tráfego de amostra no Amazon EKS e no Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [Configurar memcached com um exportador de métricas no Amazon EKS e no Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Configurar amostra de workload do Java/JMX para o Amazon EKS e o Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [Configurar HAProxycom um exportador de métricas no Amazon EKS e no Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Tutorial para adicionar um novo destino de extração do Prometheus: Redis OSS em clusters do Amazon EKS e do Kubernetes](ContainerInsights-Prometheus-Setup-redis-eks.md)
# Configurar amostra de workload AWS App Mesh para o Amazon EKS e o Kubernetes
O suporte do Prometheus no CloudWatch Container Insights oferece suporte a AWS App Mesh. As seções a seguir explicam como configurar o App Mesh.
**Topics**
+ [Configurar a amostra de workload AWS App Mesh em um cluster do Amazon EKS com o tipo de inicialização do EC2 ou um cluster do Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Configurar a amostra de workload AWS App Mesh em um cluster do Amazon EKS com o tipo de inicialização do Fargate](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# Configurar a amostra de workload AWS App Mesh em um cluster do Amazon EKS com o tipo de inicialização do EC2 ou um cluster do Kubernetes
Use estas instruções ao configurar o App Mesh em um cluster que executa o Amazon EKS com o tipo de inicialização do EC2 ou em um cluster do Kubernetes.
## Configurar permissões do IAM
É necessário adicionar a política **AWSAppMeshFullAccess** à função do IAM para seu grupo de nós do Amazon EKS ou do Kubernetes. No Amazon EKS, esse nome de grupo de nós é semelhante a `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL`. No Kubernetes, ele pode ser semelhante a `nodes.integ-test-kops-prometheus.k8s.local`.
## Instalar o App Mesh
Para instalar o controlador do App Mesh Kubernetes, siga as instruções em [Controlador do App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller).
## Instalar uma amostra de aplicação
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples) contém várias demonstrações do Kubernetes App Mesh. Com este tutorial, você instala uma amostra de aplicação de cor que mostra como as rotas http podem usar cabeçalhos para correspondência de solicitações recebidas.
**Para usar uma amostra de aplicação do App Mesh amostra para testar Insights de contêiner**
1. Instale a aplicação usando estas instruções: [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. Inicie um pod de curler para gerar tráfego:
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. Execute curl em diferentes endpoints alterando cabeçalhos HTTP. Execute o comando curl várias vezes, conforme mostrado:
```
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 o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Na região da AWS em que o cluster está em execução, escolha **Metrics** (Métricas) no painel de navegação. A métrica está no namespace **ContainerInsights/Prometheus**.
1. Para visualizar os eventos do CloudWatch Logs, escolha **Log Groups** (Grupos de logs) no painel de navegação. Os eventos estão no grupo de logs ` /aws/containerinsights/your_cluster_name/prometheus ` no fluxo de logs `kubernetes-pod-appmesh-envoy`.
## Excluir o ambiente de teste do App Mesh
Ao terminar de usar o App Mesh e a aplicação de exemplo, use os comandos a seguir para excluir os recursos desnecessários. Excluir a aplicação de exemplo inserindo o comando a seguir:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
Excluir o controlador do App Mesh inserindo o comando a seguir:
```
helm delete appmesh-controller -n appmesh-system
```
# Configurar a amostra de workload AWS App Mesh em um cluster do Amazon EKS com o tipo de inicialização do Fargate
Use estas instruções ao configurar o App Mesh em um cluster que executa o Amazon EKS com o tipo de inicialização do Fargate.
## Configurar permissões do IAM
Insira o seguinte comando para definir as permissões do IAM. Substitua *MyCluster* pelo nome do cluster.
```
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
```
## Instalar o App Mesh
Para instalar o controlador do App Mesh Kubernetes, siga as instruções em [Controlador do App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller). Siga as instruções para o Amazon EKS com o tipo de inicialização do Fargate.
## Instalar uma amostra de aplicação
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples) contém várias demonstrações do Kubernetes App Mesh. Neste tutorial, você instala uma amostra de aplicaçao de cor que funciona para clusters do Amazon EKS com o tipo de inicialização do Fargate.
**Para usar uma amostra de aplicação do App Mesh amostra para testar Insights de contêiner**
1. Instale a aplicação usando estas instruções: [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).
Essas instruções pressupõem que você esteja criando um novo cluster com o perfil correto do Fargate. Caso queira usar um cluster do Amazon EKS que você já configurou, use os seguintes comandos para configurar o cluster para esta demonstração. Substitua *MyCluster* pelo nome do cluster.
```
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. Encaminhe pela porta a implantação frontal da aplicação:
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. Execute curl na aplicação frontal:
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Na região da AWS em que o cluster está em execução, escolha **Metrics** (Métricas) no painel de navegação. A métrica está no namespace **ContainerInsights/Prometheus**.
1. Para visualizar os eventos do CloudWatch Logs, escolha **Log Groups** (Grupos de logs) no painel de navegação. Os eventos estão no grupo de logs ` /aws/containerinsights/your_cluster_name/prometheus ` no fluxo de logs `kubernetes-pod-appmesh-envoy`.
## Excluir o ambiente de teste do App Mesh
Ao terminar de usar o App Mesh e a aplicação de exemplo, use os comandos a seguir para excluir os recursos desnecessários. Excluir a aplicação de exemplo inserindo o comando a seguir:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
Excluir o controlador do App Mesh inserindo o comando a seguir:
```
helm delete appmesh-controller -n appmesh-system
```
# Configurar o NGINX com tráfego de amostra no Amazon EKS e no Kubernetes
O NGINX é um servidor web que também pode ser usado como load balancer e proxy reverso. Para obter mais informações sobre como o Kubernetes usa o NGINX para entrada, consulte [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx).
**Como instalar o Ingress-NGINX com uma amostra de serviço de tráfego para testar o suporte ao Container Insights Prometheus**
1. Insira comando a seguir para adicionar o repositório ingress-nginx do Helm:
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. Insira os comandos a seguir:
```
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. Verifique se os serviços foram iniciados corretamente inserindo o comando a seguir:
```
kubectl get service -n nginx-ingress-sample
```
A saída deste comando deve exibir várias colunas, incluindo uma coluna `EXTERNAL-IP`.
1. Defina uma variável `EXTERNAL-IP` para o valor da coluna `EXTERNAL-IP` na linha do controlador de entrada do NGINX.
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. Inicie alguns exemplos de tráfego do NGINX inserindo o comando a seguir.
```
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. Insira o comando a seguir para confirmar se todos os três pods estão no status `Running`.
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
Se eles estiverem em execução, logo você verá as métricas no namespace **ContainerInsights/Prometheus** .
**Como desinstalar o NGINX e o aplicativo de tráfego de exemplo**
1. Exclua o serviço de tráfego de exemplo inserindo o comando a seguir:
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Exclua a saída do NGINX pelo nome da versão do Helm.
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# Configurar memcached com um exportador de métricas no Amazon EKS e no Kubernetes
memcached é um sistema de armazenamento em cache de objetos na memória de código aberto. Para obter mais informações, consulte [O que é Memcached](https://www.memcached.org)?
Se você estiver executando o memcached em um cluster com o tipo de inicialização do Fargate, precisará configurar um perfil do Fargate antes de executar as etapas deste procedimento. Para configurar o perfil, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**Como instalar memcached com um exportador de métricas para testar o suporte do Container Insights Prometheus**
1. Insira comando a seguir para adicionar o repositório:
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. Insira o comando a seguir para criar um novo namespace:
```
kubectl create namespace memcached-sample
```
1. Insira o comando a seguir para instalar o 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. Insira o comando a seguir para confirmar a anotação do serviço em execução:
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
Você verá as duas anotações a seguir:
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**Como desinstalar o memcached**
+ Insira os comandos a seguir:
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Configurar amostra de workload do Java/JMX para o Amazon EKS e o Kubernetes
O JMX Exporter é um exportador oficial do Prometheus que pode extrair conteúdo e expor mBeans da JMX como métricas do Prometheus. Para obter mais informações, consulte [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
O Container Insights pode coletar métricas predefinidas do Prometheus a partir da Java Virtual Machine (JVM), Java e Tomcat (Catalina) usando o JMX Exporter.
## Configuração padrão de extração do Prometheus
Por padrão, o atendente do CloudWatch com suporte ao Prometheus extrai as métricas do Java/JMX do Prometheus de `http://CLUSTER_IP:9404/metrics` em cada pod em um cluster do Amazon EKS ou do Kubernetes. Isso é feito pela detecção `role: pod` do Prometheus `kubernetes_sd_config`. 9404 é a porta padrão alocada para o JMX Exporter pelo Prometheus. Para obter mais informações sobre a detecção `role: pod`, consulte [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). Você pode configurar o JMX Exporter de modo a expor as métricas em uma porta ou metrics\$1path diferente. Se você alterar a porta ou o caminho, atualize o jmx scrape\$1config padrão no mapa de configuração do atendente do CloudWatch. Execute o comando a seguir para obter a configuração do Prometheus atual do atendente do CloudWatch:
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
Os campos a serem alterados são os campos `/metrics` e `regex: '.*:9404$'`, conforme destacado no exemplo a seguir.
```
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:
```
## Outra configuração de extração do Prometheus
Se você expuser sua aplicação em execução em um conjunto de pods com exportadores Java/JMX Prometheus por um Kubernetes Service, também será possível alternar para usar detecção `role: service` ou detecção `role: endpoint` do Prometheus `kubernetes_sd_config`. Para obter mais informações sobre esses métodos de detecção, consulte [serviço](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service), [endpoints](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints) e[.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
Mais meta rótulos são fornecidos por esses dois modos de detecção de serviço que podem ser úteis para você criar as dimensões de métricas do CloudWatch. Por exemplo, é possível rotular `__meta_kubernetes_service_name` como `Service` e incluí-lo na dimensão de suas métricas. Para obter mais informações sobre como personalizar suas métricas do CloudWatch e suas dimensões, consulte [Configuração do atendente do CloudWatch para o Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config).
## Imagem do docker com o JMX Exporter
Crie uma imagem do Docker. As seções a seguir fornecem dois exemplos de Dockerfiles.
Quando você tiver compilado a imagem, carregue-a no Amazon EKS ou no Kubernetes e execute o comando a seguir para verificar se as métricas do Prometheus são expostas por `JMX_EXPORTER` na porta 9404. Substitua *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD* pelo nome do pod em execução e substitua *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* pelo namespace do aplicativo.
Se você estiver executando o JMX Exporter em um cluster com o tipo de inicialização do Fargate, precisará configurar um perfil do Fargate antes de executar as etapas deste procedimento. Para configurar o perfil, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster.
```
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
```
## Exemplo: imagem do Docker do Apache Tomcat com métricas do Prometheus
O servidor Apache Tomcat expõe mBeans da JMX por padrão. Você pode integrar o JMX Exporter ao Tomcat para expor o mBeans da JMX como métricas do Prometheus. O exemplo de dockerfile a seguir mostra as etapas para criação de uma imagem de teste:
```
# 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"]
```
A lista a seguir explica as quatro linhas `COPY` deste dockerfile.
+ Faça download do arquivo jar mais recente do JMX Exporter em [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
+ `config.yaml` é o arquivo de configuração do JMX Exporter. Para obter mais informações, consulte [https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ).
Veja a seguir um arquivo de configuração de exemplo para Java e 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` é um script de inicialização do Tomcat para iniciar o JMX exporter com o Tomcat e expor métricas do Prometheus na porta 9404 do localhost. Ele também fornece ao JMX Exporter o caminho do arquivo `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"
```
+ o aplicativo web .war é o arquivo de aplicativo web `war` a ser carregado pelo Tomcat.
Crie uma imagem do Docker com essa configuração e carregue para um repositório de imagens.
## Exemplo: imagem do Docker da aplicação Java Jar com métricas do Prometheus
O exemplo de dockerfile a seguir mostra as etapas para criação de uma imagem de teste:
```
# 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
```
A lista a seguir explica as quatro linhas `COPY` deste dockerfile.
+ Faça download do arquivo jar mais recente do JMX Exporter em [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
+ `config.yaml` é o arquivo de configuração do JMX Exporter. Para obter mais informações, consulte [https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ).
Veja a seguir um arquivo de configuração de exemplo para Java e 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` é o script para iniciar o aplicativo JAR com as métricas exportadas do Prometheus. Ele também fornece ao JMX Exporter o caminho do arquivo `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 é o arquivo jar do aplicativo Java de amostra. Substitua-o pelo aplicativo Java que você deseja monitorar.
Crie uma imagem do Docker com essa configuração e carregue para um repositório de imagens.
# Configurar HAProxycom um exportador de métricas no Amazon EKS e no Kubernetes
HAProxy é um aplicativo proxy de código aberto. Para obter mais informações, consulte [HAProxy](https://www.haproxy.org).
Se você estiver executando o HAProxyem um cluster com o tipo de inicialização do Fargate, precisará configurar um perfil do Fargate antes de executar as etapas deste procedimento. Para configurar o perfil, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**Como instalar o HAProxy com um exportador de métricas para testar o suporte do Container Insights Prometheus**
1. Insira o comando a seguir para adicionar o repositório da incubadora do Helm:
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. Insira o comando a seguir para criar um novo namespace:
```
kubectl create namespace haproxy-ingress-sample
```
1. Insira os comandos a seguir para instalar o 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. Insira o comando a seguir para confirmar a anotação do serviço:
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
Você verá as anotações a seguir.
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**Como desinstalar o HAProxy**
+ Insira os comandos a seguir:
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Tutorial para adicionar um novo destino de extração do Prometheus: Redis OSS em clusters do Amazon EKS e do Kubernetes
Este tutorial apresenta uma introdução prática para extrair as métricas do Prometheus de um exemplo de aplicação do Redis em um cluster do Amazon EKS e do Kubernetes. O Redis OSS (https://redis.io/) é um armazenamento de estrutura de dados em memória com código aberto (licença BSD), usado como banco de dados, cache e agente de mensagens. Para obter mais informações, consulte [ redis](https://redis.io/).
O redis\$1exporter (licença MIT) é usado para expor as métricas do Prometheus no Redis OSS na porta especificada (padrão: 0.0.0.0:9121). Para obter mais informações, consulte [redis\$1exporter](https://github.com/oliver006/redis_exporter).
As imagens do Docker dos dois repositórios do Docker Hub a seguir são usadas neste tutorial:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [ redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Para instalar um exemplo de workload do Redis OSS que expõe as métricas do Prometheus**
1. Defina o namespace para a workload de exemplo do Redis OSS.
```
REDIS_NAMESPACE=redis-sample
```
1. Se você estiver executando o Redis OSS em um cluster com o tipo de inicialização do Fargate, precisará configurar um perfil do Fargate. Para configurar o perfil, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. Instale a workload de exemplo do Redis inserindo o comando a seguir.
```
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. A instalação inclui um serviço chamado `my-redis-metrics` que expõe a métrica do Prometheus no Redis OSS na porta 9121. Insira o seguinte comando para obter os detalhes do serviço:
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
Na seção `Annotations` dos resultados, você verá duas anotações que correspondem à configuração de extração do Prometheus do atendente do CloudWatch, para que ele possa detectar as workloads automaticamente:
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
A configuração de extração do Prometheus relacionada pode ser encontrada na seção `- job_name: kubernetes-service-endpoints` de`kubernetes-eks.yaml` ou `kubernetes-k8s.yaml`.
**Para começar a coletar métricas do Prometheus no Redis OSS no CloudWatch**
1. Baixe a versão mais recente do arquivo `kubernetes-eks.yaml` ou `kubernetes-k8s.yaml` inserindo um dos comandos a seguir. Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira 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 um cluster do Amazon EKS com o tipo de inicialização do Fargate, insira 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
```
Para um cluster do Kubernetes em execução em uma instância do Amazon EC2, insira 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-k8s.yaml
```
1. Abra o arquivo com um editor de textos e localize a seção `cwagentconfig.json`. Adicione a seguinte subseção e salve as alterações. Verifique se o recuo segue o padrão existente.
```
{
"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$"
]
},
```
A seção que você adicionou coloca as métricas do Redis OSS na lista de permissões do agente do CloudWatch. Para obter a lista dessas métricas, consulte a seção a seguir.
1. Se você já tem o atendente do CloudWatch com suporte ao Prometheus implantado nesse cluster, exclua-o inserindo o comando a seguir.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Implante o atendente do CloudWatch com a configuração atualizada inserindo um dos comandos a seguir. Substitua *MyCluster* e *region* para corresponder a suas configurações.
Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira este comando.
```
kubectl apply -f prometheus-eks.yaml
```
Para um cluster do Amazon EKS com o tipo de inicialização do Fargate, insira este comando.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Para um cluster do Kubernetes, insira este comando.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Visualizar suas métricas do Prometheus no Redis OSS
Este tutorial envia as seguintes métricas ao namespace **ContainerInsights/Prometheus** no CloudWatch. É possível usar o console do CloudWatch para ver as métricas nesse namespace.
| Nome da métrica | Dimensões |
| --- | --- |
| `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**
O valor da dimensão **cmd** pode ser: `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` ou `slowlog`.
Os valores da dimensão **db** podem ser `db0` ou `db15`.
Também é possível criar um painel do CloudWatch para suas métricas do Prometheus no Redis OSS.
**Para criar um painel para métricas do Prometheus no Redis OSS**
1. Crie variáveis de ambiente, substituindo os valores abaixo para corresponder a sua implantação.
```
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. Use o comando a seguir para criar o painel.
```
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" \
```