Etapa 1: Criar um namespace para o CloudWatch Etapa 2: Criar uma conta de serviço no cluster Etapa 3: Criar um ConfigMap para o atendente do CloudWatch Etapa 4: Implantar o atendente do CloudWatch como um DaemonSet

Configurar o atendente do CloudWatch para coletar 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 mais informações e instruções, consulte Instalar o complemento Amazon CloudWatch Observability do EKS.

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 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 da 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.

Usar o 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 da 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"]

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 especificando 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

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

Edite o arquivo YAML obtido por download da seguinte forma:
- cluster_name: 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.
(Opcional) Faça alterações adicionais no ConfigMap com base nos requisitos de monitoramento da seguinte forma:
- metrics_collection_interval: 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_override: 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_flush_interval: 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 .
```
"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"
            }
        }
    }
}
```
Crie o ConfigMap no cluster executando o comando a seguir.
```
kubectl apply -f cwagent-configmap.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

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
```
2. Remova o comentário da seção port no arquivo cwagent-daemonset.yaml da seguinte forma:
```
ports:
  - containerPort: 8125
    hostPort: 8125
    protocol: UDP
```
3. Implante o atendente do CloudWatch no cluster executando o comando a seguir.
```
kubectl apply -f cwagent-daemonset.yaml
```
4. 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
```

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
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Configuração de início rápido para o Container Insights no Amazon EKS e no Kubernetes

Usar o AWS Distro for OpenTelemetry