# Configuração do agente do CloudWatch para a coleta de métricas do cluster
**Importante**
Se estiver instalando o Container Insights em um cluster do Amazon EKS, recomendamos que use o complemento de observabilidade do EKS do Amazon CloudWatch para a instalação em vez de usar as instruções desta seção. Para obter mais informações e instruções, consulte [Introdução ao complemento Amazon CloudWatch Observability do EKS](Container-Insights-setup-EKS-addon.md).
Para configurar o Container Insights para coletar métricas, siga as etapas em [Configuração de início rápido para o Container Insights no Amazon EKS e no Kubernetes](Container-Insights-setup-EKS-quickstart.md) ou siga as etapas nesta seção. Nas etapas a seguir, você configura o atendente do CloudWatch para ser capaz de coletar métricas dos clusters.
Se estiver instalando em um cluster do Amazon EKS e usar as instruções desta seção em ou após 6 de novembro de 2023, você instalará o Container Insights com observabilidade aprimorada para o Amazon EKS no cluster.
## Etapa 1: Criar um namespace para o CloudWatch
Use a seguinte etapa para criar um namespace do Kubernetes chamado `amazon-cloudwatch` para o CloudWatch. Ignore essas etapas se você já tiver criado esse namespace.
**Para criar um namespace para o CloudWatch**
+ 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/daemonset/container-insights-monitoring/cloudwatch-namespace.yaml
```
## Etapa 2: Criar uma conta de serviço no cluster
Aplique um dos métodos a seguir para criar uma conta de serviço para o agente do CloudWatch, se ainda não tiver uma.
+ Use `kubectl`
+ Usar um arquivo `kubeconfig`
### Usar `kubectl` para autenticação
**Para usar `kubectl` para criar uma conta de serviço para o agente do CloudWatch**
+ 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/daemonset/container-insights-monitoring/cwagent/cwagent-serviceaccount.yaml
```
Se você não seguiu as etapas anteriores, mas já tem uma conta de serviço para o atendente do CloudWatch que deseja usar, deve garantir que ela tenha as regras a seguir. Além disso, no restante das etapas da instalação do Container Insights, você deve usar o nome da conta de serviço em vez de `cloudwatch-agent`.
```
rules:
- apiGroups: [""]
resources: ["pods", "nodes", "endpoints"]
verbs: ["list", "watch"]
- apiGroups: [ "" ]
resources: [ "services" ]
verbs: [ "list", "watch" ]
- apiGroups: ["apps"]
resources: ["replicasets", "daemonsets", "deployments", "statefulsets"]
verbs: ["list", "watch"]
- apiGroups: ["batch"]
resources: ["jobs"]
verbs: ["list", "watch"]
- apiGroups: [""]
resources: ["nodes/proxy"]
verbs: ["get"]
- apiGroups: [""]
resources: ["nodes/stats", "configmaps", "events"]
verbs: ["create", "get"]
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["cwagent-clusterleader"]
verbs: ["get","update"]
- nonResourceURLs: ["/metrics"]
verbs: ["get", "list", "watch"]
- apiGroups: [ "discovery.k8s.io" ]
resources: [ "endpointslices" ]
verbs: [ "list", "watch", "get" ]
```
### Usar `kubeconfig` para autenticação
Também é possível usar um arquivo `kubeconfig` para autenticação. Esse método permite que você contorne a necessidade de uma conta de serviço ao especificar diretamente o caminho de `kubeconfig` na configuração do seu agente do CloudWatch. Ele também permite que você remova sua dependência da API de ambiente de gerenciamento do Kubernetes para autenticação, simplificando sua configuração e aumentando potencialmente a segurança ao gerenciar a autenticação por meio de seu arquivo kubeconfig.
Para usar esse método, atualize o arquivo de configuração do agente do CloudWatch para especificar o caminho para o arquivo `kubeconfig`, como no exemplo a seguir.
```
{
"logs": {
"metrics_collected": {
"kubernetes": {
"cluster_name": "YOUR_CLUSTER_NAME",
"enhanced_container_insights": false,
"accelerated_compute_metrics": false,
"tag_service": false,
"kube_config_path": "/path/to/your/kubeconfig"
"host_ip": "HOSTIP"
}
}
}
}
```
Para criar um arquivo `kubeconfig`, crie uma Solicitação de Assinatura de Certificado (CSR) para o usuário `admin/{create_your_own_user}` com a função `system:masters` do Kubernetes. Em seguida, assine com a Autoridade Certificadora (CA) do cluster Kubernetes e crie o arquivo `kubeconfig`.
## Etapa 3: Criar um ConfigMap para o atendente do CloudWatch
Siga as etapas a seguir para criar um ConfigMap para o atendente do CloudWatch.
**Para criar um ConfigMap para o atendente do CloudWatch**
1. Faça download do YAML do ConfigMap para o host do cliente `kubectl` executando o seguinte comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-configmap-enhanced.yaml
```
1. Edite o arquivo YAML obtido por download da seguinte forma:
+ **cluster\$1name**: na seção `kubernetes`, substitua `{{cluster_name}}` pelo nome do cluster. Remova os caracteres `{{}}`. Se preferir, caso esteja usando um cluster do Amazon EKS, você poderá excluir o campo `"cluster_name"` e o valor. Se fizer isso, o atendente do CloudWatch detectará o nome do cluster a partir das etiquetas do Amazon EC2.
1. (Opcional) Faça alterações adicionais no ConfigMap com base nos requisitos de monitoramento da seguinte forma:
+ **metrics\$1collection\$1interval**: na seção `kubernetes`, você pode especificar com que frequência o atendente coleta métricas. O padrão é 60 segundos. O intervalo de coleta do cadvisor padrão em kubelet é de 15 segundos, portanto, não defina esse valor para menos de 15 segundos.
+ **endpoint\$1override**: na seção `logs`, você poderá especificar o endpoint do CloudWatch Logs se desejar substituir o endpoint padrão. Você pode querer fazer isso se estiver publicando de um cluster em uma VPC e quiser que os dados vão para um VPC endpoint.
+ **force\$1flush\$1interval**: na seção `logs`, você pode especificar o intervalo para agrupar em lote os eventos de log antes que eles sejam publicados no CloudWatch Logs. O padrão é 5 segundos.
+ **region**: por padrão, o atendente publicou métricas para a Região em que o nó de processamento está localizado. Para substituir isso, você pode adicionar um campo `region` na seção `agent`: por exemplo, `"region":"us-west-2"`.
+ Seção **statsd**: se quiser que o atendente do CloudWatch Logs também execute um StatsD em cada nó de processamento do cluster, você poderá adicionar uma seção `statsd` à seção `metrics`, conforme o exemplo a seguir. Para obter informações sobre outras opções do StatsD para essa seção, consulte [Recuperar métricas personalizadas com o StatsD](CloudWatch-Agent-custom-metrics-statsd.md).
```
"metrics": {
"metrics_collected": {
"statsd": {
"service_address":":8125"
}
}
}
```
Um exemplo completo da seção JSON é o seguinte. Se você estiver usando um arquivo `kubeconfig` para autenticação, adicione o parâmetro `kube_config_path` para especificar o caminho para seu arquivo kubeconfig.
```
{
"agent": {
"region": "us-east-1"
},
"logs": {
"metrics_collected": {
"kubernetes": {
"cluster_name": "MyCluster",
"metrics_collection_interval": 60,
"kube_config_path": "/path/to/your/kubeconfig" //if using kubeconfig for authentication
}
},
"force_flush_interval": 5,
"endpoint_override": "logs.us-east-1.amazonaws.com"
},
"metrics": {
"metrics_collected": {
"statsd": {
"service_address": ":8125"
}
}
}
}
```
1. Crie o ConfigMap no cluster executando o comando a seguir.
```
kubectl apply -f cwagent-configmap-enhanced.yaml
```
## Etapa 4: Implantar o atendente do CloudWatch como um DaemonSet
Para concluir a instalação do atendente do CloudWatch e começar a coletar métricas de contêiner, siga as etapas a seguir.
**Para implantar o atendente do CloudWatch como um DaemonSet**
1.
+ Para não usar o StatsD no cluster, 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/daemonset/container-insights-monitoring/cwagent/cwagent-daemonset.yaml
```
+ Para usar o StatsD, siga estas etapas:
1. Faça download do YAML do DaemonSet para o host do cliente `kubectl` executando o comando a seguir.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/cwagent/cwagent-daemonset.yaml
```
1. Remova o comentário da seção `port` no arquivo `cwagent-daemonset.yaml` da seguinte forma:
```
ports:
- containerPort: 8125
hostPort: 8125
protocol: UDP
```
1. Implante o atendente do CloudWatch no cluster executando o comando a seguir.
```
kubectl apply -f cwagent-daemonset.yaml
```
1. Implante o agente do CloudWatch nos nós do Windows em seu cluster ao executar o comando apresentado a seguir. O receptor StatsD não é compatível com o agente do CloudWatch no Windows.
```
kubectl apply -f cwagent-daemonset-windows.yaml
```
1. Confirme se o atendente está implantado executando o comando a seguir.
```
kubectl get pods -n amazon-cloudwatch
```
Quando for concluído, o atendente do CloudWatch criará um grupo de logs chamado `/aws/containerinsights/Cluster_Name/performance` e enviará os eventos de log de performance a esse grupo de logs. Se você também configurar o atendente como um listener do StatsD, o atendente também escutará as métricas do StatsD na porta 8125 com o endereço IP do nó no qual o pod do aplicativo está programado.
### Solução de problemas
Se o atendente não for implantado corretamente, tente o seguinte:
+ Execute o comando a seguir para obter a lista de pods.
```
kubectl get pods -n amazon-cloudwatch
```
+ Execute o comando a seguir e verifique os eventos na parte inferior da saída.
```
kubectl describe pod pod-name -n amazon-cloudwatch
```
+ Execute o comando a seguir para verificar os logs.
```
kubectl logs pod-name -n amazon-cloudwatch
```