# Instalar o atendente do CloudWatch com a coleção de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes
Esta seção explica como configurar o atendente do CloudWatch com monitoramento do Prometheus em um cluster que está executando o Amazon EKS ou o Kubernetes. Depois que você fizer isso, o atendente automaticamente extrairá e importará métricas para as seguintes workloads em execução nesse cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Também é possível configurar o atendente para extrair e importar outras workloads e origens do Prometheus.
Antes de seguir estas etapas de instalação do atendente do CloudWatch para coleta de métricas do Prometheus, você deve ter um cluster em execução no Amazon EKS ou um cluster do Kubernetes em execução em uma instância do Amazon EC2.
**Requisitos para grupo de segurança de VPC**
As regras de entrada dos grupos de segurança para as workloads do Prometheus devem abrir as portas do Prometheus para o atendente do CloudWatch para extrair as métricas Prometheus pelo IP privado.
As regras de saída do grupo de segurança do atendente do CloudWatch devem permitir que o atendente do CloudWatch se conecte à porta das workloads do Prometheus por IP privado.
**Topics**
+ [Instalar o atendente do CloudWatch com a coleção de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes](#ContainerInsights-Prometheus-Setup-roles)
+ [Extrair outras fontes do Prometheus e importar essas métricas](ContainerInsights-Prometheus-Setup-configure.md)
+ [(Opcional) Configurar workloads de exemplo do Amazon EKS em contêineres para teste de métrica do Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md)
## Instalar o atendente do CloudWatch com a coleção de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes
Esta seção explica como configurar o atendente do CloudWatch com monitoramento do Prometheus em um cluster que está executando o Amazon EKS ou o Kubernetes. Depois que você fizer isso, o atendente automaticamente extrairá e importará métricas para as seguintes workloads em execução nesse cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
Também é possível configurar o atendente para extrair e importar outras workloads e origens do Prometheus.
Antes de seguir estas etapas de instalação do atendente do CloudWatch para coleta de métricas do Prometheus, você deve ter um cluster em execução no Amazon EKS ou um cluster do Kubernetes em execução em uma instância do Amazon EC2.
**Requisitos para grupo de segurança de VPC**
As regras de entrada dos grupos de segurança para as workloads do Prometheus devem abrir as portas do Prometheus para o atendente do CloudWatch para extrair as métricas Prometheus pelo IP privado.
As regras de saída do grupo de segurança do atendente do CloudWatch devem permitir que o atendente do CloudWatch se conecte à porta das workloads do Prometheus por IP privado.
**Topics**
+ [Configurar funções do IAM](#ContainerInsights-Prometheus-Setup-roles)
+ [Instalar o atendente do CloudWatch para coletar métricas do Prometheus](#ContainerInsights-Prometheus-Setup-install-agent)
### Configurar funções do IAM
A primeira etapa é configurar a função do IAM necessária no cluster. Há dois métodos:
+ Configurar uma função do IAM para uma conta de serviço, também conhecida como *função de serviço*. Esse método funciona tanto para o tipo de inicialização do EC2 como para o tipo de inicialização do Fargate.
+ Adicione uma política do IAM à função do IAM usada para o cluster. Isso funciona apenas para o tipo de inicialização do EC2.
**Configurar uma função de serviço (tipo de inicialização do EC2 e tipo de inicialização do Fargate)**
Para configurar uma função de serviço, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster.
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**Adicionar uma política ao perfil do IAM do grupo de nós (apenas o tipo de inicialização do EC2)**
**Para configurar a política do IAM em um grupo de nós para compatibilidade com o Prometheus**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Você precisa encontrar o prefixo do nome da função do IAM para o cluster. Para fazer isso, marque a caixa de seleção ao lado do nome de uma instância que está no cluster e escolha **Ações**, **Segurança**, **Modificar perfil do IAM**. Copie o prefixo da função do IAM, como `eksctl-dev303-workshop-nodegroup`.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Perfis**.
1. Use a caixa de pesquisa para localizar o prefixo copiado anteriormente neste procedimento e escolha a função.
1. Escolha **Anexar políticas**.
1. Use a caixa de pesquisa para localizar o **CloudWatchAgentServerPolicy**. Marque a caixa de seleção ao lado de **CloudWatchAgentServerPolicy** e escolha **Attach policy (Anexar política)**.
### Instalar o atendente do CloudWatch para coletar métricas do Prometheus
Você deve instalar o atendente do CloudWatch no cluster para coletar as métricas. O método de instalação do atendente é diferente para clusters do Amazon EKS e clusters do Kubernetes.
**Excluir versões anteriores do atendente do CloudWatch compatíveis com Prometheus**
Se você já instalou em seu cluster uma versão do atendente do CloudWatch com suporte ao Prometheus, exclua essa versão inserindo o comando a seguir. Isso é necessário apenas para versões anteriores do atendente com suporte ao Prometheus. Não é necessário excluir o atendente do CloudWatch que habilita o Container Insights sem suporte ao Prometheus.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### Instalar o atendente CloudWatch em clusters do Amazon EKS com o tipo de inicialização do EC2
Para instalar o atendente do CloudWatch com suporte ao Prometheus em um cluster do Amazon EKS, siga estas etapas.
**Para instalar o atendente do CloudWatch com suporte ao Prometheus em um cluster do Amazon EKS**
1. Insira o comando a seguir para verificar se o namespace `amazon-cloudwatch` já foi criado:
```
kubectl get namespace
```
1. Se `amazon-cloudwatch` não for exibido nos resultados, crie-o inserindo o comando a seguir:
```
kubectl create namespace amazon-cloudwatch
```
1. Para implantar o atendente com a configuração padrão e fazer com que ele envie dados para a região da AWS em que está instalado, insira o comando a seguir:
```
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
```
Em vez disso, para que o atendente envie dados para uma região diferente, siga estas etapas:
1. Faça download do arquivo YAML para o atendente inserindo o comando a seguir:
```
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 o arquivo com um editor de textos e procure o bloco `cwagentconfig.json` do arquivo.
1. Adicione as linhas realçadas, especificando a região desejada:
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. Salve o arquivo e implante o atendente usando o arquivo atualizado.
```
kubectl apply -f prometheus-eks.yaml
```
#### Instalar o atendente CloudWatch em clusters do Amazon EKS com o tipo de inicialização do Fargate
Para instalar o atendente do CloudWatch com suporte ao Prometheus em um cluster do Amazon EKS com tipo de inicialização do Fargate, siga estas etapas.
**Para instalar o atendente do CloudWatch com suporte ao Prometheus em um cluster do Amazon EKS com tipo de inicialização do Fargate**
1. Insira o comando a seguir para criar um perfil Fargate para o atendente do CloudWatch de modo que ele possa ser executado dentro do cluster. Substitua *MyCluster* pelo nome do cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. Para instalar o atendente do CloudWatch, insira o comando a seguir. Substitua *MyCluster* pelo nome do cluster. Esse nome é usado no nome do grupo de logs que armazena os eventos de log coletados pelo atendente, além de ser usado como uma dimensão para as métricas coletadas pelo atendente.
Substitua a *region* pelo nome da região para onde você deseja que as métricas sejam enviadas. Por exemplo, `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 -
```
#### Instalar o atendente do CloudWatch em um cluster do Kubernetes
Para instalar o atendente do CloudWatch com suporte ao Prometheus em um cluster do Kubernetes em execução, insira 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/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
Substitua *MyCluster* pelo nome do cluster. Esse nome é usado no nome do grupo de logs que armazena os eventos de log coletados pelo atendente, além de ser usado como uma dimensão para as métricas coletadas pelo atendente.
Substitua a *região* pelo nome da região da AWS para onde você deseja que as métricas sejam enviadas. Por exemplo, **us-west-1**.
#### Verificar se o atendente está em execução
Nos clusters do Amazon EKS e do Kubernetes, você pode inserir o seguinte comando para confirmar se o atendente está em execução.
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
Se os resultados incluírem um único pod de atendente do CloudWatch no estado `Running`, o atendente está em execução e coletando métricas do Prometheus. Por padrão, o atendente do CloudWatch coleta métricas para App Mesh, NGINX, Memcached, Java/JMX e HAProxy a cada minuto. Para obter mais informações sobre essas métricas, consulte [Métricas do Prometheus coletadas pelo atendente do CloudWatch](ContainerInsights-Prometheus-metrics.md). Para obter instruções sobre como ver as métricas do Prometheus no CloudWatch, consulte [Visualizar as métricas do Prometheus](ContainerInsights-Prometheus-viewmetrics.md)
Você também pode configurar o atendente do CloudWatch para coletar métricas de outros exportadores do Prometheus. Para obter mais informações, consulte [Extrair outras fontes do Prometheus e importar essas métricas](ContainerInsights-Prometheus-Setup-configure.md).
# Extrair outras fontes do Prometheus e importar essas métricas
O atendente do CloudWatch com monitoramento Prometheus precisa de duas configurações para extrair as métricas do Prometheus. Uma serve para as configurações padrão do Prometheus, conforme documentado em [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) na documentação do Prometheus. A outra é para a configuração do atendente do CloudWatch.
Para clusters do Amazon EKS, as configurações são definidas em`prometheus-eks.yaml` (para o tipo de inicialização EC2) ou `prometheus-eks-fargate.yaml` (para o tipo de inicialização do Fargate) como dois mapas de configuração:
+ A seção `name: prometheus-config` contém as configurações para extração de conteúdo do Prometheus.
+ A seção `name: prometheus-cwagentconfig` contém a configuração para o atendente do CloudWatch. Você pode usar esta seção para configurar como as métricas do Prometheus são coletadas pelo CloudWatch. Por exemplo, você pode especificar quais métricas devem ser importadas ao CloudWatch e definir suas dimensões.
Para clusters do Kubernetes em execução em instâncias do Amazon EC2, as configurações são definidas no arquivo YAML `prometheus-k8s.yaml` como dois mapas de configuração:
+ A seção `name: prometheus-config` contém as configurações para extração de conteúdo do Prometheus.
+ A seção `name: prometheus-cwagentconfig` contém a configuração para o atendente do CloudWatch.
Para extrair outras origens de métricas do Prometheus e importar essas métricas para o CloudWatch, modifique a configuração de extração do Prometheus e a configuração do atendente do CloudWatch e implante novamente o atendente com a configuração atualizada.
**Requisitos para grupo de segurança de VPC**
As regras de entrada dos grupos de segurança para as workloads do Prometheus devem abrir as portas do Prometheus para o atendente do CloudWatch para extrair as métricas Prometheus pelo IP privado.
As regras de saída do grupo de segurança do atendente do CloudWatch devem permitir que o atendente do CloudWatch se conecte à porta das workloads do Prometheus por IP privado.
## Configuração de extração do Prometheus
O atendente do CloudWatch oferece suporte às configurações de extração padrão do Prometheus, conforme documentado em [ ](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) na documentação do Prometheus. É possível editar essa seção para atualizar as configurações que já estão nesse arquivo e adicionar outros destinos de extração do Prometheus. Por padrão, um exemplo de arquivo de configuração contém as seguintes linhas de configuração global:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval**: define a frequência da adição de destinos de extração de conteúdo.
+ **scrape\$1timeout**: define quanto tempo aguardar até a expiração de uma solicitação de extração de conteúdo.
Também é possível definir valores diferentes para essas configurações no nível do trabalho, a fim de substituir as configurações globais.
### Trabalhos de extração do Prometheus
Os arquivos YAML do atendente do CloudWatch já têm alguns trabalhos padrão de extração configurados. Por exemplo, em `prometheus-eks.yaml`, os trabalhos de extração padrão são configurados nas linhas `job_name` da seção `scrape_configs`. Nesse arquivo, a seguinte seção padrão `kubernetes-pod-jmx` extrai métricas do 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
```
Cada um desses destinos padrão é extraído e as métricas são enviadas ao CloudWatch em eventos de log usando o formato de métricas incorporado. Para obter mais informações, consulte [Incorporação de métricas em logs](CloudWatch_Embedded_Metric_Format.md).
Os eventos de log dos clusters do Amazon EKS e do Kubernetes são armazenados no grupo de logs **/aws/containerinsights/*cluster\$1name*/prometheus** no CloudWatch Logs. Os eventos de log dos clusters do Amazon ECS são armazenados no grupo de logs **/aws/ecs/containerinsights/*cluster\$1name*/prometheus**.
Cada trabalho de extração está contido em um fluxo de logs diferente nesse grupo de logs. Por exemplo, o trabalho de extração do Prometheus `kubernetes-pod-appmesh-envoy` é definido para o App Mesh. Todas as métricas do App Mesh Prometheus de clusters do Amazon EKS e do Kubernetes são enviadas ao fluxo de logs chamado **/aws/containerinsights/*cluster\$1name*>prometheus/kubernetes-pod-appmesh-envoy/**.
Para adicionar um novo destino de extração, adicione uma nova seção `job_name` à seção `scrape_configs` do arquivo YAML e reinicie o atendente. Para obter um exemplo desse processo, consulte [Tutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus](#ContainerInsights-Prometheus-Setup-new-exporters).
## Configuração do atendente do CloudWatch para o Prometheus
O arquivo de configuração do atendente do CloudWatch tem uma seção `prometheus` na seção `metrics_collected` para a configuração de extração do Prometheus. Contém as seguintes opções de configuração:
+ **cluster\$1name**: especifica o nome do cluster a ser adicionado como um rótulo no evento de log. Esse campo é opcional. Se você omitir, o atendente poderá detectar o nome do cluster do Amazon EKS ou do Kubernetes.
+ **log\$1group\$1name**: especifica o nome do grupo de log para as métricas do Prometheus extraídas. Esse campo é opcional. Se você omitir, o CloudWatch usará **/aws/containerinsights/*cluster\$1name*/prometheus** para logs de clusters do Amazon EKS e do Kubernetes.
+ **prometheus\$1config\$1path**: especifica o caminho do arquivo de configuração de extração do Prometheus. Se o valor desse campo começar com `env:`, o conteúdo do arquivo de configuração de extração do Prometheus será recuperado da variável de ambiente do contêiner. Não altere esse campo.
+ **ecs\$1service\$1discovery**: é a seção para especificar a configuração da detecção de serviço do Amazon ECS Prometheus. Para obter mais informações, consulte [Guia detalhado para detecção automática em clusters do Amazon ECS](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md).
A seção `ecs_service_discovery` pode conter os seguintes campos:
+ `sd_frequency` é a frequência para detectar os exportadores Prometheus. Especifique um número e um sufixo de unidade. Por exemplo, `1m` uma vez por minuto ou `30s` uma vez a cada 30 segundos. Os sufixos de unidade válidos são: `ns`, `us`, `ms`, `s`, `m` e `h`.
Esse campo é opcional. O padrão é 60 segundos (1 minuto).
+ `sd_target_cluster` é o nome do cluster do Amazon ECS de destino para detecção automática. Esse campo é opcional. O padrão é o nome do cluster do Amazon ECS em que o atendente do CloudWatch está instalado.
+ `sd_cluster_region` é a região do cluster do Amazon ECS de destino. Esse campo é opcional. O padrão é a região do cluster do Amazon ECS em que o atendente do CloudWatch está instalado.
+ `sd_result_file` é o caminho do arquivo YAML para os resultados de destino do Prometheus. A configuração de extração do Prometheus referenciará esse arquivo.
+ `docker_label` é uma seção opcional que você pode usar para especificar a configuração para detecção de serviço baseada em rótulos do docker. Se você omitir essa seção, a detecção baseada em rótulos do docker não será usada. A seção pode conter os seguintes campos:
+ `sd_port_label` é o nome do rótulo do docker do contêiner que especifica a porta do contêiner para métricas do Prometheus. O valor padrão é `ECS_PROMETHEUS_EXPORTER_PORT`. Se o contêiner não tiver esse rótulo do docker, o atendente do CloudWatch o ignorará.
+ `sd_metrics_path_label` é o nome do rótulo do docker do contêiner que especifica o caminho das métricas do Prometheus. O valor padrão é `ECS_PROMETHEUS_METRICS_PATH`. Se o contêiner não tiver esse rótulo do docker, o agente assumirá o caminho padrão `/metrics`.
+ `sd_job_name_label` é o nome do rótulo do docker do contêiner que especifica o nome do trabalho de extração do Prometheus. O valor padrão é `job`. Se o contêiner não tiver esse rótulo do docker, o atendente do CloudWatch usará o nome do trabalho na configuração de extração do Prometheus.
+ `task_definition_list` é uma seção opcional que você pode usar para especificar a configuração para detectção de serviço baseada em definição de tarefa. Se você omitir essa seção, a detecção baseada em definição de tarefa não será usada. A seção pode conter os seguintes campos:
+ `sd_task_definition_arn_pattern` é o padrão a ser usado para especificar as definições de tarefa do Amazon ECS a serem detectadas. Essa é uma expressão regular.
+ `sd_metrics_ports` lista a containerPort para as métricas do Prometheus. Separe as containerPorts com ponto e vírgula.
+ `sd_container_name_pattern` especifica os nomes de contêiner de tarefas do Amazon ECS. Essa é uma expressão regular.
+ `sd_metrics_path` especifica o caminho da métrica do Prometheus. Se você omitir isso, o atendente assumirá o caminho padrão `/metrics`
+ `sd_job_name` especifica o nome do trabalho de extração do Prometheus. Se você omitir esse campo, o atendente do CloudWatch usará o nome do trabalho na configuração de extração do Prometheus.
+ **metric\$1declaration**: são seções que especificam a matriz de logs com formato de métrica incorporado a ser gerada. Há seções `metric_declaration` para cada destino do Prometheus do qual o atendente do CloudWatch importa por padrão. Essas seções incluem os seguintes campos:
+ `label_matcher` é uma expressão regular que confere o valor dos rótulos listados em `source_labels`. As métricas correspondentes são disponibilizadas para inclusão no formato de métrica incorporado enviado ao CloudWatch.
Se você tiver vários rótulos especificados em `source_labels`, recomendamos não utilizar os caracteres `^` ou `$` na expressão regular para `label_matcher`.
+ `source_labels` especifica o valor dos rótulos verificados pela linha `label_matcher`.
+ `label_separator` especifica o separador a ser usado na linha ` label_matcher` se vários `source_labels` forem especificados. O padrão é `;`. É possível ver esse padrão usado na linha `label_matcher` no exemplo a seguir.
+ `metric_selectors` é uma expressão regular que especifica as métricas a serem coletadas e enviadas ao CloudWatch.
+ `dimensions` é a lista de rótulos a serem usados como dimensões do CloudWatch para cada métrica selecionada.
Veja o exemplo de `metric_declaration` a seguir.
```
"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$"
]
}
]
```
Esse exemplo configura uma seção de formato de métrica incorporada a ser enviada como um evento de log se as seguintes condições forem atendidas:
+ O valor de `Service` contém `node-exporter` ou `kube-dns`.
+ O valor de `Namespace` é `kube-system`.
+ A métrica do Prometheus `coredns_dns_request_type_count_total` contém rótulos `Service` e `Namespace`.
O evento de log enviado inclui a seguinte seção destacada:
```
{
"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 adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus
O servidor de API do Kubernetes expõe métricas do Prometheus em endpoints por padrão. O exemplo oficial da configuração de extração do servidor de API do Kubernetes está disponível no [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml).
O tutorial a seguir mostra como executar as seguintes etapas para começar a importar métricas do servidor de API do Kubernetes para o CloudWatch:
+ Como adicionar a configuração de extração do Prometheus para o servidor de API do Kubernetes ao arquivo YAML do atendente do CloudWatch.
+ Como configurar as definições de métricas em formato de métrica incorporada no arquivo YAML do atendente do CloudWatch.
+ (Opcional) Como criar um painel do CloudWatch para as métricas do servidor de API do Kubernetes.
**nota**
O servidor de API do Kubernetes expõe métricas de indicador, contador, histograma e resumo. Nesta versão do suporte a métricas do Prometheus, o CloudWatch importa apenas as métricas com tipos de indicador e contador.
**Como começar a coletar métricas do servidor de API do Kubernetes do Prometheus no CloudWatch**
1. Baixe a versão mais recente do arquivo `prometheus-eks.yaml`, `prometheus-eks-fargate.yaml` ou `prometheus-k8s.yaml` inserindo um dos comandos a seguir.
Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira o comando a seguir:
```
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 o comando a seguir:
```
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 o comando a seguir:
```
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 texto, localize a seção `prometheus-config` e adicione a seção a seguir nela. Salve as alterações:
```
# 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. Enquanto o arquivo YAML ainda está aberto no editor de texto, encontre a seção `cwagentconfig.json`. Adicione a seguinte subseção e salve as alterações. Esta seção coloca as métricas do servidor de API na lista de permissões do atendente do CloudWatch. Três tipos de métricas do servidor de API são adicionados à lista de permissões:
+ contagens de objetos etcd
+ Métricas do controlador de registro do servidor de API
+ Métricas de solicitação do servidor de 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. Se você já tem o atendente do CloudWatch com suporte ao Prometheus implantado no 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. Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira:
```
kubectl apply -f prometheus-eks.yaml
```
Para um cluster do Amazon EKS com o tipo de inicialização do Fargate, insira o comando a seguir. Substitua *MyCluster* e *region* com valores para corresponder a sua implantação.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Para um cluster do Kubernetes, insira o comando a seguir. Substitua *MyCluster* e *region* com valores para corresponder a sua implantação.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Uma vez feito isso, será necessário ver um novo stream de log chamado ** kubernetes-apiservers ** no grupo de log **/aws/containerinsights/*cluster\$1name*/prometheus**. Esse fluxo de logs deve incluir eventos de log com uma definição de formato de métrica incorporada como a seguinte:
```
{
"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"
}
```
Você pode visualizar suas métricas no console do CloudWatch no namespace **ContainerInsights/Prometheus**. Também é possível criar um painel do CloudWatch para as métricas do servidor de API do Kubernetes do Prometheus.
### (Opcional) Criar um painel para as métricas do servidor de API do Kubernetes
Para ver as métricas do servidor de API do Kubernetes em seu painel, é necessário ter concluído primeiro as etapas nas seções anteriores para começar a coletar essas métricas no CloudWatch.
**Como criar um painel para métricas do servidor de API do Kubernetes**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Verifique se você selecionou a região da AWS correta.
1. No painel de navegação, escolha **Painéis**.
1. Escolha **Create dashboard (Criar painel)**. Insira um nome para o novo painel e escolha **Create dashboard (Criar painel)**.
1. Em **Add to this dashboard (Adicionar a este painel)**, escolha **Cancel (Cancelar)**.
1. Escolha **Actions (Ações)**, **View/edit source (Exibir/editar origem)**.
1. Faça o download do seguinte arquivo JSON: [Origem do painel da API do Kubernetes](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 o arquivo JSON obtido por download com um editor de textos e faça as seguintes alterações:
+ Substitua todas as strings `{{YOUR_CLUSTER_NAME}}` pelo nome exato do cluster. Não adicione espaços em branco antes ou depois do texto.
+ Substitua todas as strings `{{YOUR_AWS_REGION}}` pelo nome da região onde as métricas são coletadas. Por exemplo, `us-west-2`. Não adicione espaços em branco antes ou depois do texto.
1. Copie todo o blob JSON e cole-o na caixa de texto no console do CloudWatch, substituindo o que já está na caixa.
1. Escolha **Update (Atualizar)**, **Save dashboard (Salvar painel)**.
# (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" \
```