# Monitoramento de métricas do Container Insights Prometheus O monitoramento do CloudWatch Container Insights para Prometheus automatiza a detecção de métricas do Prometheus de sistemas e workloads em contêineres. O Prometheus é um toolkit de código aberto para alertas e monitoramento de sistemas. Para obter mais informações, consulte [What is Prometheus?](https://prometheus.io/docs/introduction/overview/) na documentação do Prometheus. A detecção de métricas do Prometheus é compatível com clusters do [Amazon Elastic Container Service](https://aws.amazon.com/ecs/), [Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/) e [Kubernetes](https://aws.amazon.com/kubernetes/) em execução em instâncias do Amazon EC2. São coletados os tipos de métrica contador, medidor e resumo do Prometheus. Para clusters do Amazon ECS e do Amazon EKS, há suporte para os tipos de inicialização do EC2 e do Fargate. O Container Insights coleta automaticamente métricas de várias workloads, e é possível configurá-lo de modo a coletar métricas de qualquer workload. Você pode adotar o Prometheus como um método de código aberto e padrão aberto para ingerir métricas personalizadas no CloudWatch. O atendente do CloudWatch com suporte ao Prometheus detecta e coleta métricas do Prometheus para monitorar, solucionar problemas e criar alarmes sobre a degradação na performance e falhas das aplicações mais rapidamente. Isso também reduz o número de ferramentas de monitoramento necessárias para melhorar a observabilidade. O suporte do Container Insights Prometheus envolve o pagamento de métricas e logs conforme o uso, incluindo coleta, armazenamento e análise. Para obter mais informações, consulte [Preços do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). **Painéis pré-criados para algumas workloads** A solução Container Insights Prometheus contém painéis pré-criados para as workloads bastante utilizadas listadas nesta seção. Para obter exemplos de configurações dessas workloads, consulte [(Opcional) Configurar amostra de workloads do Amazon ECS em contêineres para teste de métrica do Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)e [(Opcional) Configurar workloads de exemplo do Amazon EKS em contêineres para teste de métrica do Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md). Também é possível configurar o Container Insights para coletar métricas do Prometheus de outros serviços e aplicações em contêineres, editando o arquivo de configuração do atendente. Workloads com painéis pré-criados para clusters do Amazon EKS e do Kubernetes em execução em instâncias do Amazon EC2: + AWS App Mesh + NGINX + Memcached + Java/JMX + HAProxy Workloads com painéis pré-criados para clusters do Amazon ECS: + AWS App Mesh + Java/JMX + NGINX + NGINX Plus # Instalar e configurar a coleta de métricas do Prometheus em cluster do Amazon ECS Para coletar métricas do Prometheus de clusters do Amazon ECS, é possível usar o atendente do CloudWatch como coletor ou usar o coletor do AWS Distro for OpenTelemetry. Para obter informações sobre como usar o coletor do AWS Distro for OpenTelemetry, consulte [https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus). As seções a seguir explicam como usar o atendente do CloudWatch como coletor para recuperar métricas do Prometheus. Você instala o atendente do CloudWatch com o monitoramento Prometheus em clusters que executam o Amazon ECS e, opcionalmente, pode configurar o atendente para extrair outros destinos. Estas seções também fornecem tutoriais opcionais para configurar workloads de amostra para usar testes com monitoramento Prometheus. O Container Insights no Amazon ECS oferece suporte às seguintes combinações de tipo de inicialização e modo de rede para métricas do Prometheus: | Tipo de inicialização do Amazon ECS | Modos de rede compatíveis | | --- | --- | | EC2 (Linux) | bridge, host e awsvpc | | Fargate | awsvpc | **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 ECS](ContainerInsights-Prometheus-install-ECS.md) + [Extrair outras fontes do Prometheus e importar essas métricas](ContainerInsights-Prometheus-Setup-configure-ECS.md) + [(Opcional) Configurar amostra de workloads do Amazon ECS em contêineres para teste de métrica do Prometheus](ContainerInsights-Prometheus-Sample-Workloads-ECS.md) # Instalar o atendente do CloudWatch com a coleção de métricas do Prometheus em clusters do Amazon ECS Esta seção explica como configurar o atendente do CloudWatch com monitoramento do Prometheus em um cluster que está executando o Amazon ECS. 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 + Java/JMX Também é possível configurar o atendente para extrair e importar métricas de outras workloads e origens do Prometheus. ## Configurar funções do IAM Você precisa de duas funções do IAM para a definição de tarefa do atendente do CloudWatch. Se você especificar **CreateIAMRoles=True** na pilha CloudFormation para que o Container Insights crie essas funções para você, as funções serão criadas com as permissões corretas. Caso queira criá-las ou usar funções existentes, as funções e permissões a seguir são necessárias. + **Função de tarefa do ECS do atendente do CloudWatch**: o contêiner do atendente do CloudWatch usa essa função. Ela deve incluir a política **CloudWatchAgentServerPolicy** e uma política gerenciada pelo cliente que contenha as seguintes permissões somente para leitura: + `ec2:DescribeInstances` + `ecs:ListTasks` + `ecs:ListServices` + `ecs:DescribeContainerInstances` + `ecs:DescribeServices` + `ecs:DescribeTasks` + `ecs:DescribeTaskDefinition` + **Função de execução de tarefa do ECS do atendente do CloudWatch**: essa é a função necessária para o Amazon ECS iniciar e executar os contêineres. Verifique se sua função de execução de tarefa tem as políticas **AmazonSSMReadOnlyAccess**, **AmazonECSTaskExecutionRolePolicy** e **CloudWatchAgentServerPolicy** anexadas. Se precisar armazenar dados mais sigilosos para uso do Amazon ECS, consulte [Especificar dados sigilosos](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html). ## Instale o atendente do CloudWatch com o monitoramento do Prometheus usando CloudFormation Você pode usar AWS CloudFormation para instalar o atendente do CloudWatch com o monitoramento do Prometheus para clusters do Amazon ECS. A lista a seguir exibe os parâmetros que você usará no modelo CloudFormation. + **ECSClusterName**: especifica o cluster do Amazon ECS de destino. + **CreateIAMRoles**: especifique **True** para criar novas funções para a função de tarefa do Amazon ECS e para a função de execução de tarefas do Amazon ECS. Especifique **False** para reutilizar funções existentes. + **TaskRoleName**: se você especificou **True** em **CreateIAMRoles**, isso especifica o nome a ser usado para a função de tarefa do Amazon ECS. Se você especificou **False** em **CreateIAMRoles**, isso especifica a função existente a ser usada para a função de tarefa do Amazon ECS. + **ExecutionRoleName**: se você especificou **True** em **CreateIAMRoles**, isso especifica o nome a ser usado para a função de execução de tarefa do Amazon ECS. Se você especificou **False** em **CreateIAMRoles**, isso especifica a função existente a ser usada para a função de execução de tarefa do Amazon ECS. + **ECSNetworkMode**: se estiver usando o tipo de inicialização do EC2, especifique o modo de rede aqui. Deve ser **bridge** ou **host**. + **ECSLaunchType**: especifique **fargate** ou **EC2**. + **SecurityGroupID**: se o **ECSNetworkMode** for **awsvpc**, especifique o ID do grupo de segurança aqui. + **SubnetID**: se o **ECSNetworkMode** for **awsvpc**, especifique o ID da sub-rede aqui. ### Exemplos de comando Esta seção contém exemplos de comando do CloudFormation para instalar o Container Insights com o monitoramento do Prometheus em vários cenários. **Criar uma pilha do CloudFormation para um cluster do Amazon ECS no modo de rede de ponte** ``` export AWS_PROFILE=your_aws_config_profile_eg_default export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1 export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name export ECS_NETWORK_MODE=bridge export CREATE_IAM_ROLES=True export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \ ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \ ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \ ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \ ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` **Criar uma pilha do CloudFormation para um cluster do Amazon ECS no modo de rede de host** ``` export AWS_PROFILE=your_aws_config_profile_eg_default export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1 export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name export ECS_NETWORK_MODE=host export CREATE_IAM_ROLES=True export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \ ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \ ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \ ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \ ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` **Criar uma pilha do CloudFormation para um cluster do Amazon ECS no modo de rede awsvpc** ``` export AWS_PROFILE=your_aws_config_profile_eg_default export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1 export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name export ECS_LAUNCH_TYPE=EC2 export CREATE_IAM_ROLES=True export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \ --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \ ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \ ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \ ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \ ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \ ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \ ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` **Criar uma pilha do CloudFormation para um cluster do Fargate no modo de rede awsvpc** ``` export AWS_PROFILE=your_aws_config_profile_eg_default export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1 export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name export ECS_LAUNCH_TYPE=FARGATE export CREATE_IAM_ROLES=True export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \ --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \ ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \ ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \ ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \ ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \ ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \ ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` ### Recursos da AWS criados pela pilha do CloudFormation A tabela a seguir lista os recursos da AWS que são criados quando você usa o CloudFormation para configurar o Container Insights com o monitoramentodo Prometheus em um cluster do Amazon ECS. | Tipo de recurso | Nome do recurso | Comentários | | --- | --- | --- | | AWS::SSM::Parameter | AmazonCloudWatch-CWAgentConfig-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Este é o atendente do CloudWatch com a definição padrão do formato de métrica incorporado de App Mesh e Java/JMX. | | AWS::SSM::Parameter | AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | Esta é a configuração de extração do Prometheus. | | AWS::IAM::Role | **\$1ECS\$1TASK\$1ROLE\$1NAME**. | A função de tarefa do Amazon ECS. Isso somente é criado se você especificou **True** em `CREATE_IAM_ROLES`. | | AWS::IAM::Role | **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1** | A função de execução de tarefa do Amazon ECS. Isso somente é criado se você especificou **True** em `CREATE_IAM_ROLES`. | | AWS::ECS::TaskDefinition | cwagent-prometheus-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | | | AWS::ECS::Service | cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | | ### Excluir a pilha do CloudFormation para o atendente do CloudWatch com monitoramento do Prometheus Para excluir o atendente do CloudWatch de um cluster do Amazon ECS, insira estes comandos. ``` export AWS_PROFILE=your_aws_config_profile_eg_default export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1 export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name aws cloudformation delete-stack \ --stack-name ${CLOUDFORMATION_STACK_NAME} \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` # 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 ECS, as configurações são integradas ao Parameter Store do AWS Systems Manager pelos segredos na definição da tarefa do Amazon ECS: + O segredo `PROMETHEUS_CONFIG_CONTENT` é para a configuração de extração do Prometheus. + O segredo `CW_CONFIG_CONTENT` é para a configuração do 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, nos arquivos YAML para o Amazon ECS, como `cwagent-ecs-prometheus-metric-for-bridge-host.yaml`, os trabalhos de extração padrão são configurados na seção `ecs_service_discovery`. ``` "ecs_service_discovery": { "sd_frequency": "1m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { }, "task_definition_list": [ { "sd_job_name": "ecs-appmesh-colors", "sd_metrics_ports": "9901", "sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+", "sd_metrics_path": "/stats/prometheus" }, { "sd_job_name": "ecs-appmesh-gateway", "sd_metrics_ports": "9901", "sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+", "sd_metrics_path": "/stats/prometheus" } ] } ``` 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 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. Para adicionar um novo destino de extração, adicione uma nova entrada à seção `task_definition_list` na seção `ecs_service_discovery` 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-configure.md#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 ECS. + **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/ecs/containerinsights/*cluster\$1name*/prometheus** para logs de clusters do Amazon ECS. + **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 as configurações das funções de detecção automática de destino do Amazon ECS Prometheus. Dois modos são compatíveis para detectar os destinos do Prometheus: detecção baseada no rótulo do docker do contêiner ou detecção baseada na expressão regular do ARN da definição de tarefa do Amazon ECS. Você pode usar os dois modos junto, e o atendente do CloudWatch eliminará a duplicação dos destinos detectados com base em: *\$1private\$1ip\$1:\$1port\$1/\$1metrics\$1path\$1*. 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. + `service_name_list_for_tasks` é uma seção opcional que você pode usar para especificar a configuração para detecção de serviço baseada em definição de tarefa. Ao omitir esta seção, a detecção baseada em nome de serviço não será utilizada. A seção pode conter os seguintes campos: + `sd_service_name_pattern` é o padrão a ser usado para especificar o serviço do Amazon ECS em que as tarefas serão detectadas. Essa é uma expressão regular. + `sd_metrics_ports` lista a `containerPort` para as métricas do Prometheus. Separar múltiplas `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 das métricas do Prometheus. Se você omitir isso, o atendente entenderá que 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", ... } ``` # Guia detalhado para detecção automática em clusters do Amazon ECS O Prometheus fornece dezenas de mecanismos dinâmicos de detecção de serviços, conforme descrito em [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config). Porém, não há detecção de serviço integrada para o Amazon ECS. O atendente do CloudWatch adiciona esse mecanismo. Quando a detecção de serviço do Amazon ECS Prometheus é habilitada, o atendente do CloudWatch faz periodicamente as seguintes chamadas de API aos frontends do Amazon ECS e do Amazon EC2 para recuperar os metadados das tarefas do ECS em execução no cluster do ECS de destino. ``` EC2:DescribeInstances ECS:ListTasks ECS:ListServices ECS:DescribeContainerInstances ECS:DescribeServices ECS:DescribeTasks ECS:DescribeTaskDefinition ``` Os metadados são usados pelo atendente do CloudWatch para verificar os destinos do Prometheus dentro do cluster do ECS. O atendente do CloudWatch é compatível com três modos de detecção de serviço: + Detecção de serviço baseada em rótulos do docker + Detecção de serviço baseado em expressão regular do ARN da definição de tarefa do ECS + Detecção de serviço baseada em expressão regular do nome do serviço do ECS Todos os modos podem ser usados conjuntamente. O atendente do CloudWatch elimina a duplicação dos destinos detectados com base em: `{private_ip}:{port}/{metrics_path}`. Todos os destinos detectados são gravados em um arquivo de resultado especificado pela confiiguração `sd_result_file` dentro do contêiner do atendente do CloudWatch. Veja a seguir um exemplo de arquivo de resultado: ``` - targets: - 10.6.1.95:32785 labels: __metrics_path__: /metrics ECS_PROMETHEUS_EXPORTER_PORT: "9406" ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic ECS_PROMETHEUS_METRICS_PATH: /metrics InstanceType: t3.medium LaunchType: EC2 SubnetId: subnet-123456789012 TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port TaskGroup: family:demo-jar-ec2-bridge-dynamic-port TaskRevision: "7" VpcId: vpc-01234567890 container_name: demo-jar-ec2-bridge-dynamic-port job: demo-jar-ec2-bridge-dynamic - targets: - 10.6.3.193:9404 labels: __metrics_path__: /metrics ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404" ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port ECS_PROMETHEUS_METRICS_PATH: /metrics InstanceType: t3.medium LaunchType: EC2 SubnetId: subnet-123456789012 TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port TaskGroup: family:demo-jar-tomcat-bridge-mapped-port TaskRevision: "12" VpcId: vpc-01234567890 container_name: demo-tomcat-ec2-bridge-mapped-port job: demo-tomcat-ec2-bridge-mapped-port ``` É possível integrar diretamente esse arquivo de resultados à detecção de serviços baseada em arquivo do Prometheus. Para obter mais informações sobre a detecção de serviços baseada em arquivos do Prometheus, consulte [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config). Suponha que o arquivo resultante seja gravado em `/tmp/cwagent_ecs_auto_sd.yaml`. A seguinte configuração de extração do Prometheus o consumirá. ``` global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: cwagent-ecs-file-sd-config sample_limit: 10000 file_sd_configs: - files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ] ``` O atendente do CloudWatch também acrescenta os seguintes rótulos adicionais aos destinos descobertos. + `container_name` + `TaskDefinitionFamily` + `TaskRevision` + `TaskGroup` + `StartedBy` + `LaunchType` + `job` + `__metrics_path__` + Rótulos do Docker Quando o cluster tiver o tipo de inicialização do EC2, os três rótulos a seguir serão adicionados. + `InstanceType` + `VpcId` + `SubnetId` **nota** Os rótulos do Docker que não correspondem à expressão regular `[a-zA-Z_][a-zA-Z0-9_]*` são filtrados. Isso corresponde às convenções do Prometheus listadas em `label_name`em [Arquivo de configuração](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) na documentação do Prometheus. ## Exemplos de configuração de detecção de serviços do ECS Esta seção contém exemplos que demonstram a detecção de serviços do ECS. **Exemplo 1** ``` "ecs_service_discovery": { "sd_frequency": "1m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { } } ``` Este exemplo habilita a detecção de serviços baseada em rótulos do docker. O atendente do CloudWatch consultará os metadados das tarefas do ECS uma vez por minuto e gravará os destinos detectados no arquivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro do contêiner do atendente do CloudWatch. O valor padrão de `sd_port_label` na seção `docker_label` é `ECS_PROMETHEUS_EXPORTER_PORT`. Se qualquer contêiner em execução nas tarefas do ECS tiver um rótulo do docker `ECS_PROMETHEUS_EXPORTER_PORT`, o atendente do CloudWatch usará seu valor como `container port` para verificar todas as portas expostas do contêiner. Se houver uma correspondência, a porta do host mapeada mais o IP privado do contêiner serão usados para construir o destino do exportador do Prometheus neste formato: `private_ip:host_port`. O valor padrão de `sd_metrics_path_label` na seção `docker_label` é `ECS_PROMETHEUS_METRICS_PATH`. Se o contêiner tiver esse rótulo do docker, seu valor será usado como `__metrics_path__` . Se o contêiner não tiver esse rótulo, será usado o valor padrão `/metrics`. O valor padrão de `sd_job_name_label` na seção `docker_label` é `job`. Se o contêiner tiver esse rótulo do docker, seu valor será anexado como um dos rótulos do destino para substituir o nome do trabalho padrão especificado na configuração do Prometheus. O valor desse rótulo do docker será usado como o nome do fluxo de logs no grupo de logs do CloudWatch Logs. **Exemplo 2** ``` "ecs_service_discovery": { "sd_frequency": "15s", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { "sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A", "sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME" } } ``` Este exemplo habilita a detecção de serviços baseada em rótulos do docker. O atendente do CloudWatch consultará os metadados das tarefas do ECS a cada 15 segundos e gravará os destinos detectados no arquivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro do contêiner do atendente do CloudWatch. Os contêineres com o rótulo do docker `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` serão verificados. O valor do rótulo do docker `ECS_PROMETHEUS_JOB_NAME` é usado como nome do trabalho. **Exemplo 3** ``` "ecs_service_discovery": { "sd_frequency": "5m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "task_definition_list": [ { "sd_job_name": "java-prometheus", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9404; 9406", "sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+" }, { "sd_job_name": "envoy-prometheus", "sd_metrics_path": "/stats/prometheus", "sd_container_name_pattern": "^envoy$", "sd_metrics_ports": "9901", "sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23" } ] } ``` Este exemplo habilita a detecção de serviço baseado em expressão regular do ARN da definição de tarefa do ECS. O atendente do CloudWatch consultará os metadados das tarefas do ECS a cada cinco minutos e gravará os destinos detectados no arquivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro do contêiner do atendente do CloudWatch. São definidas duas seções de expressão regular do ARN da definição de tarefa: + Na primeira seção, as tarefas do ECS com `javajmx` no ARN da definição de tarefa do ECS são filtradas para a verificação da porta do contêiner. Se os contêineres dentro dessas tarefas do ECS expuserem a porta do contêiner em 9404 ou 9406, a porta do host mapeada juntamente com o IP privado do contêiner serão usados para criar os destinos do exportador do Prometheus. O valor de `sd_metrics_path` define `__metrics_path__` como `/metrics`. Assim, o atendente do CloudWatch extrairá as métricas do Prometheus de `private_ip:host_port/metrics`, e as métricas extraídas serão enviadas ao fluxo de logs `java-prometheus` no CloudWatch Logs no grupo de logs `/aws/ecs/containerinsights/cluster_name/prometheus`. + Na segunda seção, as tarefas do ECS com `appmesh` no ARN da definição de tarefa do ECS e com `version` de `:23` são filtradas para a verificação da porta do contêiner. Para contêineres com um nome de `envoy` que expõem a porta do contêiner em `9901`, a porta de host mapeada e o IP privado do contêiner são usados para criar os destinos do exportador do Prometheus. Se o valor dentro dessas tarefas do ECS expuser a porta do contêiner em 9404 ou 9406, a porta do host mapeada e o IP privado do contêiner serão usados para criar os destinos do exportador do Prometheus. O valor de `sd_metrics_path` define `__metrics_path__` como `/stats/prometheus`. Assim, o atendente do CloudWatch extrairá as métricas do Prometheus de `private_ip:host_port/stats/prometheus` e enviará as métricas extraídas ao fluxo de logs `envoy-prometheus` no CloudWatch Logs no grupo de logs `/aws/ecs/containerinsights/cluster_name/prometheus`. **Exemplo 4** ``` "ecs_service_discovery": { "sd_frequency": "5m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "service_name_list_for_tasks": [ { "sd_job_name": "nginx-prometheus", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9113", "sd_service_name_pattern": "^nginx-.*" }, { "sd_job_name": "haproxy-prometheus", "sd_metrics_path": "/stats/metrics", "sd_container_name_pattern": "^haproxy$", "sd_metrics_ports": "8404", "sd_service_name_pattern": ".*haproxy-service.*" } ] } ``` Este exemplo habilita a detecção de serviço baseado em expressão regular do nome do serviço do ECS. O atendente do CloudWatch consultará os metadados dos serviços do ECS a cada cinco minutos e gravará os destinos detectados no arquivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro do contêiner do atendente do CloudWatch. São definidas duas seções de expressão regular de nome de serviço: + Na primeira seção, as tarefas do ECS associadas aos serviços do ECS que têm nomes correspondentes à expressão regular `^nginx-.*`são filtrados para a verificação da porta do contêiner. Se os contêineres dentro dessas tarefas do ECS expuserem a porta do contêiner em 9113, a porta do host mapeada e o IP privado do contêiner serão usados para criar os destinos do exportador do Prometheus. O valor de `sd_metrics_path` define `__metrics_path__` como `/metrics`. Assim, o atendente do CloudWatch extrairá as métricas do Prometheus de `private_ip:host_port/metrics`, e as métricas extraídas serão enviadas ao fluxo de logs `nginx-prometheus` no CloudWatch Logs no grupo de logs `/aws/ecs/containerinsights/cluster_name/prometheus`. + Na segunda seção, as tarefas do ECS associadas aos serviços do ECS que têm nomes correspondentes à expressão regular `.*haproxy-service.*`são filtrados para a verificação da porta do contêiner. Para contêineres com um nome de `haproxy` que expõem a porta do contêiner em 8404, a porta de host mapeada e o IP privado do contêiner são usados para criar os destinos do exportador do Prometheus. O valor de `sd_metrics_path` define `__metrics_path__` como `/stats/metrics`. Assim, o atendente do CloudWatch extrairá as métricas do Prometheus de `private_ip:host_port/stats/metrics`, e as métricas extraídas serão enviadas ao fluxo de logs `haproxy-prometheus` no CloudWatch Logs no grupo de logs `/aws/ecs/containerinsights/cluster_name/prometheus`. **Exemplo 5** ``` "ecs_service_discovery": { "sd_frequency": "1m30s", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { "sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL", "sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL", "sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL" } "task_definition_list": [ { "sd_metrics_ports": "9150", "sd_task_definition_arn_pattern": "*memcached.*" } ] } ``` Este exemplo habilita os dois modos de detecção de serviços do ECS. O atendente do CloudWatch consultará os metadados das tarefas do ECS a cada 90 segundos e gravará os destinos detectados no arquivo `/tmp/cwagent_ecs_auto_sd.yaml` dentro do contêiner do atendente do CloudWatch. Para a configuração de detecção de serviços baseada em docker: + As tarefas do ECS com rótulo do docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` serão filtradas para a verificação de porta do Prometheus. A porta do contêiner do Prometheus de destino é especificada pelo valor do rótulo `MY_PROMETHEUS_EXPORTER_PORT_LABEL`. + Utiliza-se o valor do rótulo do docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` para `__metrics_path__`. Se o contêiner não tiver esse rótulo do docker, será usado o valor padrão `/metrics`. + O valor do rótulo do docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` é usado como rótulo do trabalho. Se o contêiner não tiver esse rótulo do docker, será usado o nome do trabalho definido na configuração do Prometheus. Para configuração da detecção de serviço baseado em expressão regular do ARN da definição de tarefa do ECS: + As tarefas do ECS com `memcached` no ARN da definição de tarefa do ECS são filtradas para verificação da porta do contêiner. A porta de contêiner do Prometheus de destino é 9150, conforme definido por `sd_metrics_ports`. É usado o caminho padrão das métricas `/metrics`. É usado o nome do trabalho definido na configuração do Prometheus. # (Opcional) Configurar amostra de workloads do Amazon ECS 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). **Topics** + [Exemplo de workload do App Mesh para clusters do Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md) + [Exemplo de workload do Java/JMX para clusters do Amazon ECS](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md) + [Exemplo de workload do NGINX para clusters do Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-ecs.md) + [Exemplo de workload do NGINX Plus para clusters do Amazon ECS](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md) + [Tutorial para adicionar um novo destino de extração do Prometheus: Memcached no Amazon ECS](ContainerInsights-Prometheus-Setup-memcached-ecs.md) + [Tutorial para extração de métricas do Prometheus no Redis OSS no Amazon ECS Fargate](ContainerInsights-Prometheus-Setup-redis-ecs.md) # Exemplo de workload do App Mesh para clusters do Amazon ECS Para coletar métricas de uma amostra de workload do Prometheus para o Amazon ECS, é necessário estar executando o Container Insights no cluster. Para obter informações sobre como instalar o Container Insights, consulte [Configurar o Container Insights no Amazon ECS](deploy-container-insights-ECS.md). Primeiro, siga esta [demonstração](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs) para implantar a amostra de aplicação de cores em seu cluster do Amazon ECS. Ao terminar, você terá métricas do App Mesh Prometheus expostas na porta 9901. Em seguida, siga estas etapas para instalar o atendente do CloudWatch com o monitoramento Prometheus no mesmo cluster do Amazon ECS em que você instalou a aplicação de cores. As etapas desta seção instalam o atendente do CloudWatch no modo de rede de ponte. As variáveis de ambiente `ENVIRONMENT_NAME`, `AWS_PROFILE` e `AWS_DEFAULT_REGION`que você definir na demonstração também serão usadas nas etapas a seguir. **Para instalar o atendente do CloudWatch com monitoramento do Prometheus para teste** 1. Baixe o modelo do CloudFormation inserindo o comando a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml ``` 1. Defina o modo de rede inserindo os comandos a seguir. ``` export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME} export ECS_NETWORK_MODE=bridge ``` 1. Crie a pilha do CloudFormation inserindo os comandos abaixo. ``` aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \ ParameterKey=CreateIAMRoles,ParameterValue=True \ ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \ ParameterKey=TaskRoleName,ParameterValue=CWAgent-Prometheus-TaskRole-${ECS_CLUSTER_NAME} \ ParameterKey=ExecutionRoleName,ParameterValue=CWAgent-Prometheus-ExecutionRole-${ECS_CLUSTER_NAME} \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` 1. (Opcional) Quando a pilha do CloudFormation for criada, você verá a mensagem `CREATE_COMPLETE`. Se conferir o status antes de visualizar essa mensagem, insira o comando a seguir. ``` aws cloudformation describe-stacks \ --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --query 'Stacks[0].StackStatus' \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` **Solução de problemas do** As etapas da demonstração usam jq para analisar o resultado de saída da AWS CLI. Para obter mais informações sobre como instalar o jq, consulte [jq](https://stedolan.github.io/jq/). Use o comando a seguir para definir o formato de saída padrão da AWS CLI para JSON, de modo que o jq possa analisá-lo corretamente. ``` $ aws configure ``` Quando a resposta chegar a `Default output format`, insira **json**. ## Instalar o atendente do CloudWatch com monitoramento do Prometheus Quando terminar de testar, insira o comando a seguir para desinstalar o atendente do CloudWatch excluindo a pilha do CloudFormation. ``` aws cloudformation delete-stack \ --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --region ${AWS_DEFAULT_REGION} \ --profile ${AWS_PROFILE} ``` # Exemplo de workload do Java/JMX para clusters do Amazon ECS 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 atendente do CloudWatch com suporte ao Prometheus extrai as métricas do Java/JMX Prometheus com base na configuração de detecção de serviço no cluster do Amazon ECS. Você pode configurar o JMX Exporter de modo a expor as métricas em uma porta ou metrics\$1path diferente. Se alterar a porta ou o caminho, atualize a seção `ecs_service_discovery` padrão na configuração do atendente do CloudWatch. Para coletar métricas de uma amostra de workload do Prometheus para o Amazon ECS, é necessário estar executando o Container Insights no cluster. Para obter informações sobre como instalar o Container Insights, consulte [Configurar o Container Insights no Amazon ECS](deploy-container-insights-ECS.md). **Para instalar o exemplo de workload do Java/JMX para clusters do Amazon ECS** 1. Siga as etapas destas seções para criar suas imagens do Docker. + [Exemplo: imagem do Docker da aplicação Java Jar com métricas do Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar) + [Exemplo: imagem do Docker do Apache Tomcat com métricas do Prometheus](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat) 1. Especifique os dois rótulos do docker a seguir no arquivo de definição de tarefa do Amazon ECS. Em seguida, é possível executar a definição da tarefa como um serviço do Amazon ECS ou uma tarefa do Amazon ECS no cluster. + Defina `ECS_PROMETHEUS_EXPORTER_PORT` para apontar para a containerPort onde as métricas do Prometheus estão expostas. + Defina `Java_EMF_Metrics` como `true`. O atendente do CloudWatch usa esse sinalizador para gerar o formato de métrica incorporado no evento de log. Este é um exemplo: ``` { "family": "workload-java-ec2-bridge", "taskRoleArn": "{{task-role-arn}}", "executionRoleArn": "{{execution-role-arn}}", "networkMode": "bridge", "containerDefinitions": [ { "name": "tomcat-prometheus-workload-java-ec2-bridge-dynamic-port", "image": "your_docker_image_tag_for_tomcat_with_prometheus_metrics", "portMappings": [ { "hostPort": 0, "protocol": "tcp", "containerPort": 9404 } ], "dockerLabels": { "ECS_PROMETHEUS_EXPORTER_PORT": "9404", "Java_EMF_Metrics": "true" } } ], "requiresCompatibilities": [ "EC2" ], "cpu": "256", "memory": "512" } ``` A configuração padrão do atendente do CloudWatch no modelo CloudFormation permite a detecção de serviços baseada em rótulos do docker e a detecção de serviços baseada no ARN da definição de tarefa. Para exibir essas configurações padrão, consulte a linha 65 do [arquivo de configurações YAML do atendente do CloudWatch](https://github.com/aws-samples/amazon-cloudwatch-container-insights/blob/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml#L65). Os contêineres com o rótulo `ECS_PROMETHEUS_EXPORTER_PORT` serão descobertos automaticamente com base na porta de contêiner especificada para extração do Prometheus. A configuração padrão do atendente do CloudWatch também tem a configuração `metric_declaration` para Java/JMX na linha 112 do mesmo arquivo. Todos os rótulos do docker dos contêineres de destino serão acrescentados como rótulos adicionais nas métricas do Prometheus e enviados ao CloudWatch Logs. Para os contêineres Java/JMX com rótulo do docker `Java_EMF_Metrics=“true”`, será gerado o formato de métrica incorporado. # Exemplo de workload do NGINX para clusters do Amazon ECS O exportador do NGINX Prometheus pode extrair e expor dados do NGINX como métricas do Prometheus. Este exemplo usa o exportador com o serviço de proxy reverso do NGINX para o Amazon ECS. Para obter mais informações sobre o exportador do NGINX Prometheus, consulte [nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) no Github. Para obter mais informações sobre o proxy reverso do NGINX, consulte [ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy) no Github. O atendente do CloudWatch com suporte ao Prometheus extrai as métricas do NGINX Prometheus com base na configuração de detecção de serviço no cluster do Amazon ECS. Você pode configurar o NGINX Prometheus Exporter de modo a expor as métricas em uma porta ou um caminho diferente. Se alterar a porta ou o caminho, atualize a seção `ecs_service_discovery` no arquivo de configuração do atendente do CloudWatch. ## Instalar o exemplo de workload de proxy reverso do NGINX para clusters do Amazon ECS Siga estas etapas para instalar o exemplo de workload de proxy reverso do NGINX. ### Criar as imagens do Docker **Para criar as imagens do Docker para o exemplo de workload de proxy reverso do NGINX** 1. Baixe esta pasta do repositório de proxy reverso do NGINX:[ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/). 1. Encontre o diretório `app` e crie uma imagem a partir desse diretório: ``` docker build -t web-server-app ./path-to-app-directory ``` 1. Crie uma imagem personalizada para o NGINX. Primeiro, crie um diretório com estes dois arquivos: + Um exemplo de Dockerfile: ``` FROM nginx COPY nginx.conf /etc/nginx/nginx.conf ``` + Um arquivo `nginx.conf`, modificado a partir de [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/): ``` events { worker_connections 768; } http { # Nginx will handle gzip compression of responses from the app server gzip on; gzip_proxied any; gzip_types text/plain application/json; gzip_min_length 1000; server{ listen 8080; location /stub_status { stub_status on; } } server { listen 80; # Nginx will reject anything not matching /api location /api { # Reject requests with unsupported HTTP method if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) { return 405; } # Only requests matching the whitelist expectations will # get sent to the application server proxy_pass http://app:3000; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection 'upgrade'; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_cache_bypass $http_upgrade; } } } ``` **nota** `stub_status` deve estar habilitado na mesma porta de onde `nginx-prometheus-exporter` está configurado para extrair métricas. Em nosso exemplo de definição de tarefa, `nginx-prometheus-exporter` está configurado para extrar métricas da porta 8080. 1. Crie uma imagem a partir de arquivos em seu novo diretório: ``` docker build -t nginx-reverse-proxy ./path-to-your-directory ``` 1. Carregue as novas imagens para um repositório de imagens para uso posterior. ### Crie a definição de tarefa para executar o NGINX e a aplicação de servidor da Web no Amazon ECS Em seguida, configure a definição de tarefa. Essa definição de tarefa permite a coleta e exportação de métricas do NGINX Prometheus. O contêiner do NGINX rastreia a entrada da aplicação e expõe esses dados à porta 8080, conforme definido em `nginx.conf`. O contêiner do exportador do NGINX Prometheus extrai essas métricas e as publica na porta 9113, para serem usadas no CloudWatch. **Para configurar a definição de tarefa para o exemplo de workload do NGINX no Amazon ECS** 1. Crie um arquivo JSON de definição de tarefa com o seguinte conteúdo. Substitua *your-customized-nginx-iamge* pelo URI de imagem para sua imagem do NGINX personalizada e substitua *your-web-server-app-image* pelo URI de imagem de sua imagem de aplicação do servidor da Web. ``` { "containerDefinitions": [ { "name": "nginx", "image": "your-customized-nginx-image", "memory": 256, "cpu": 256, "essential": true, "portMappings": [ { "containerPort": 80, "protocol": "tcp" } ], "links": [ "app" ] }, { "name": "app", "image": "your-web-server-app-image", "memory": 256, "cpu": 256, "essential": true }, { "name": "nginx-prometheus-exporter", "image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0", "memory": 256, "cpu": 256, "essential": true, "command": [ "-nginx.scrape-uri", "http://nginx:8080/stub_status" ], "links":[ "nginx" ], "portMappings":[ { "containerPort": 9113, "protocol": "tcp" } ] } ], "networkMode": "bridge", "placementConstraints": [], "family": "nginx-sample-stack" } ``` 1. Insira o comando a seguir para registrar a definição de tarefa. ``` aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json ``` 1. Crie um serviço para executar a tarefa inserindo o comando a seguir: Não altere o nome do serviço. Executaremos um serviço de atendente do CloudWatch usando uma configuração que procura tarefas usando os padrões de nome dos serviços que os iniciaram. Por exemplo, para que o atendente do CloudWatch localize a tarefa iniciada por este comando, é possível especificar o valor de `sd_service_name_pattern` como `^nginx-service$`. A próxima seção oferece mais detalhes. ``` aws ecs create-service \ --cluster your-cluster-name \ --service-name nginx-service \ --task-definition nginx-sample-stack:1 \ --desired-count 1 ``` ### Configurar o atendente do CloudWatch para extrair métricas do NGINX Prometheus A etapa final é configurar o atendente do CloudWatch para extrair as métricas do NGINX. Neste exemplo, o atendente do CloudWatch detecta a tarefa por meio do padrão de nome de serviço e da porta 9113, onde o exportador expõe as métricas prometheus para o NGINX. Com a tarefa detectada e as métricas disponíveis, o atendente do CloudWatch começa a publicar as métricas coletadas no fluxo de logs **nginx-prometheus-exporter**. **Para configurar o atendente do CloudWatch para extrair métricas do NGINX** 1. Baixe a versão mais recente do arquivo YAML necessário inserindo um dos comandos a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml ``` 1. Abra o arquivo com um editor de textos e encontre a confguração completa do atendente do CloudWatch na chave `value` da seção `resource:CWAgentConfigSSMParameter`. Depois, na seção `ecs_service_discovery`, adicione a seção `service_name_list_for_tasks` a seguir. ``` "service_name_list_for_tasks": [ { "sd_job_name": "nginx-prometheus-exporter", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9113", "sd_service_name_pattern": "^nginx-service$" } ], ``` 1. No mesmo arquivo, insira a seguinte seção na seção `metric_declaration` para permitir métricas do NGINX. Siga o padrão de recuo existente. ``` { "source_labels": ["job"], "label_matcher": ".*nginx.*", "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]], "metric_selectors": [ "^nginx_.*$" ] }, ``` 1. Se você ainda não tiver o atendente do CloudWatch implantado nesse cluster, pule para a etapa 8. Se já tiver o atendente do CloudWatch implantado no cluster do Amazon ECS usando o AWS CloudFormation, é possível criar um conjunto de alterações inserindo os seguintes comandos: ``` ECS_CLUSTER_NAME=your_cluster_name AWS_REGION=your_aws_region ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION \ --change-set-name nginx-scraping-support ``` 1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/). 1. Revisar o changeset recém-criado **nginx-scraping-support**. Você deverá ver uma alteração aplicada ao recurso **CWAgentConfigSSMParameter**. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo este comando: ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 0 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Aguarde cerca de 10 segundos e insira este comando. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Se você estiver instalando o atendente do CloudWatch com coleta de métricas do Prometheus no cluster pela primeira vez, insira estes comandos. ``` ECS_CLUSTER_NAME=your_cluster_name AWS_REGION=your_aws_region ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION ``` ## Visualizar métricas e logs do NGINX Agora é possível visualizar as métricas do NGINX que estão sendo coletadas. **Para visualizar as métricas do exemplo de workload do NGINX** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Na região da em que o cluster está em execução, escolha **Metrics** (Métricas) no painel de navegação à esquerda. Encontre o namespace **ContainerInsights/Prometheus** para ver as métricas. 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\$1cluster\$1name*/prometheus**, no fluxo de logs *nginx-prometheus-exporter*. # Exemplo de workload do NGINX Plus para clusters do Amazon ECS O NGINX Plus é a versão comercial do NGINX. É necessário ter uma licença para usá-lo. Para obter mais informações, consulte [NGINX Plus](https://www.nginx.com/products/nginx/). O exportador do NGINX Prometheus pode extrair e expor dados do NGINX como métricas do Prometheus. Este exemplo usa o exportador com o serviço de proxy reverso do NGINX Plus para o Amazon ECS. Para obter mais informações sobre o exportador do NGINX Prometheus, consulte [nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) no Github. Para obter mais informações sobre o proxy reverso do NGINX, consulte [ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy) no Github. O atendente do CloudWatch com suporte ao Prometheus extrai as métricas do NGINX Plus Prometheus com base na configuração de detecção de serviço no cluster do Amazon ECS. Você pode configurar o NGINX Prometheus Exporter de modo a expor as métricas em uma porta ou um caminho diferente. Se alterar a porta ou o caminho, atualize a seção `ecs_service_discovery` no arquivo de configuração do atendente do CloudWatch. ## Instalar o exemplo de workload de proxy reverso do NGINX Plus para clusters do Amazon ECS Siga estas etapas para instalar o exemplo de workload de proxy reverso do NGINX. ### Criar as imagens do Docker **Para criar as imagens do Docker para o exemplo de workload de proxy reverso do NGINX Plus** 1. Baixe esta pasta do repositório de proxy reverso do NGINX:[ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/). 1. Encontre o diretório `app` e crie uma imagem a partir desse diretório: ``` docker build -t web-server-app ./path-to-app-directory ``` 1. Crie uma imagem personalizada para o NGINX Plus. Para poder criar a imagem para o NGINX Plus, é necessário obter a chave chamada `nginx-repo.key` e o certificado SSL `nginx-repo.crt` para seu NGINX Plus licenciado. Crie um diretório e armazene em seus arquivos `nginx-repo.key` e `nginx-repo.crt`. No diretório que você acabou de criar, crie estes dois arquivos: + Um exemplo de Dockerfile com o conteúdo a seguir. Este arquivo do docker é adotado a partir de um arquivo de exemplo disponível em [https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/\$1docker\$1plus\$1image](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image). A mudança importante que fazemos é carregar um arquivo separado, chamado `nginx.conf`, que será criado na próxima etapa. ``` FROM debian:buster-slim LABEL maintainer="NGINX Docker Maintainers “ # Define NGINX versions for NGINX Plus and NGINX Plus modules # Uncomment this block and the versioned nginxPackages block in the main RUN # instruction to install a specific release # ENV NGINX_VERSION 21 # ENV NJS_VERSION 0.3.9 # ENV PKG_RELEASE 1~buster # Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/)) # and copy to the build context COPY nginx-repo.crt /etc/ssl/nginx/ COPY nginx-repo.key /etc/ssl/nginx/ # COPY nginx.conf /etc/ssl/nginx/nginx.conf RUN set -x \ # Create nginx user/group first, to be consistent throughout Docker variants && addgroup --system --gid 101 nginx \ && adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \ && apt-get update \ && apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \ && \ NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \ found=''; \ for server in \ ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \ hkp://keyserver.ubuntu.com:80 \ hkp://p80.pool.sks-keyservers.net:80 \ pgp.mit.edu (http://pgp.mit.edu/) \ ; do \ echo "Fetching GPG key $NGINX_GPGKEY from $server"; \ apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \ done; \ test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \ apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \ # Install the latest release of NGINX Plus and/or NGINX Plus modules # Uncomment individual modules if necessary # Use versioned packages over defaults to specify a release && nginxPackages=" \ nginx-plus \ # nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \ # nginx-plus-module-xslt \ # nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \ # nginx-plus-module-geoip \ # nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \ # nginx-plus-module-image-filter \ # nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \ # nginx-plus-module-perl \ # nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \ # nginx-plus-module-njs \ # nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \ " \ && echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \ && echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \ && echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \ && echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \ && printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \ && apt-get update \ && apt-get install --no-install-recommends --no-install-suggests -y \ $nginxPackages \ gettext-base \ curl \ && apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \ && rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx # Forward request logs to Docker log collector RUN ln -sf /dev/stdout /var/log/nginx/access.log \ && ln -sf /dev/stderr /var/log/nginx/error.log COPY nginx.conf /etc/nginx/nginx.conf EXPOSE 80 STOPSIGNAL SIGTERM CMD ["nginx", "-g", "daemon off;"] ``` + Um arquivo `nginx.conf`, modificado a partir de [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx). ``` events { worker_connections 768; } http { # Nginx will handle gzip compression of responses from the app server gzip on; gzip_proxied any; gzip_types text/plain application/json; gzip_min_length 1000; upstream backend { zone name 10m; server app:3000 weight=2; server app2:3000 weight=1; } server{ listen 8080; location /api { api write=on; } } match server_ok { status 100-599; } server { listen 80; status_zone zone; # Nginx will reject anything not matching /api location /api { # Reject requests with unsupported HTTP method if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) { return 405; } # Only requests matching the whitelist expectations will # get sent to the application server proxy_pass http://backend; health_check uri=/lorem-ipsum match=server_ok; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection 'upgrade'; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_cache_bypass $http_upgrade; } } } ``` 1. Crie uma imagem a partir de arquivos em seu novo diretório: ``` docker build -t nginx-plus-reverse-proxy ./path-to-your-directory ``` 1. Carregue as novas imagens para um repositório de imagens para uso posterior. ### Crie a definição de tarefa para executar o NGINX Plus e a aplicação de servidor da Web no Amazon ECS Em seguida, configure a definição de tarefa. Essa definição de tarefa permite a coleta e exportação de métricas do NGINX Plus Prometheus. O contêiner do NGINX rastreia a entrada da aplicação e expõe esses dados à porta 8080, conforme definido em `nginx.conf`. O contêiner do exportador do NGINX Prometheus extrai essas métricas e as publica na porta 9113, para serem usadas no CloudWatch. **Para configurar a definição de tarefa para o exemplo de workload do NGINX no Amazon ECS** 1. Crie um arquivo JSON de definição de tarefa com o seguinte conteúdo. Substitua *your-customized-nginx-plus-image* pelo URI de imagem para sua imagem do NGINX Plus personalizada e substitua *your-web-server-app-image* pelo URI de imagem de sua imagem de aplicação do servidor da Web. ``` { "containerDefinitions": [ { "name": "nginx", "image": "your-customized-nginx-plus-image", "memory": 256, "cpu": 256, "essential": true, "portMappings": [ { "containerPort": 80, "protocol": "tcp" } ], "links": [ "app", "app2" ] }, { "name": "app", "image": "your-web-server-app-image", "memory": 256, "cpu": 128, "essential": true }, { "name": "app2", "image": "your-web-server-app-image", "memory": 256, "cpu": 128, "essential": true }, { "name": "nginx-prometheus-exporter", "image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0", "memory": 256, "cpu": 256, "essential": true, "command": [ "-nginx.plus", "-nginx.scrape-uri", "http://nginx:8080/api" ], "links":[ "nginx" ], "portMappings":[ { "containerPort": 9113, "protocol": "tcp" } ] } ], "networkMode": "bridge", "placementConstraints": [], "family": "nginx-plus-sample-stack" } ``` 1. Registre a definição de tarefa: ``` aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json ``` 1. Crie um serviço para executar a tarefa inserindo o comando a seguir: ``` aws ecs create-service \ --cluster your-cluster-name \ --service-name nginx-plus-service \ --task-definition nginx-plus-sample-stack:1 \ --desired-count 1 ``` Não altere o nome do serviço. Executaremos um serviço de atendente do CloudWatch usando uma configuração que procura tarefas usando os padrões de nome dos serviços que os iniciaram. Por exemplo, para que o atendente do CloudWatch localize a tarefa iniciada por este comando, é possível especificar o valor de `sd_service_name_pattern` como `^nginx-plus-service$`. A próxima seção oferece mais detalhes. ### Configurar o atendente do CloudWatch para extrair métricas do NGINX Plus Prometheus A etapa final é configurar o atendente do CloudWatch para extrair as métricas do NGINX. Neste exemplo, o atendente do CloudWatch detecta a tarefa por meio do padrão de nome de serviço e da porta 9113, onde o exportador expõe as métricas prometheus para o NGINX. Com a tarefa detectada e as métricas disponíveis, o atendente do CloudWatch começa a publicar as métricas coletadas no fluxo de logs **nginx-prometheus-exporter**. **Para configurar o atendente do CloudWatch para extrair métricas do NGINX** 1. Baixe a versão mais recente do arquivo YAML necessário inserindo um dos comandos a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml ``` 1. Abra o arquivo com um editor de textos e encontre a confguração completa do atendente do CloudWatch na chave `value` da seção `resource:CWAgentConfigSSMParameter`. Depois, na seção `ecs_service_discovery`, adicione a seção `service_name_list_for_tasks` a seguir. ``` "service_name_list_for_tasks": [ { "sd_job_name": "nginx-plus-prometheus-exporter", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9113", "sd_service_name_pattern": "^nginx-plus.*" } ], ``` 1. No mesmo arquivo, insira a seguinte seção na seção `metric_declaration` para permitir métricas do NGINX Plus. Siga o padrão de recuo existente. ``` { "source_labels": ["job"], "label_matcher": "^nginx-plus.*", "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]], "metric_selectors": [ "^nginxplus_connections_accepted$", "^nginxplus_connections_active$", "^nginxplus_connections_dropped$", "^nginxplus_connections_idle$", "^nginxplus_http_requests_total$", "^nginxplus_ssl_handshakes$", "^nginxplus_ssl_handshakes_failed$", "^nginxplus_up$", "^nginxplus_upstream_server_health_checks_fails$" ] }, { "source_labels": ["job"], "label_matcher": "^nginx-plus.*", "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "upstream"]], "metric_selectors": [ "^nginxplus_upstream_server_response_time$" ] }, { "source_labels": ["job"], "label_matcher": "^nginx-plus.*", "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "code"]], "metric_selectors": [ "^nginxplus_upstream_server_responses$", "^nginxplus_server_zone_responses$" ] }, ``` 1. Se você ainda não tiver o atendente do CloudWatch implantado nesse cluster, pule para a etapa 8. Se já tiver o atendente do CloudWatch implantado no cluster do Amazon ECS usando o AWS CloudFormation, é possível criar um conjunto de alterações inserindo os seguintes comandos: ``` ECS_CLUSTER_NAME=your_cluster_name AWS_REGION=your_aws_region ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION \ --change-set-name nginx-plus-scraping-support ``` 1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/). 1. Revisar o changeset recém-criado **nginx-plus-scraping-support**. Você deverá ver uma alteração aplicada ao recurso **CWAgentConfigSSMParameter**. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo este comando: ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 0 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Aguarde cerca de 10 segundos e insira este comando. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Se você estiver instalando o atendente do CloudWatch com coleta de métricas do Prometheus no cluster pela primeira vez, insira estes comandos. ``` ECS_CLUSTER_NAME=your_cluster_name AWS_REGION=your_aws_region ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION ``` ## Visualizar métricas e logs do NGINX Plus Agora é possível visualizar as métricas do NGINX Plus que estão sendo coletadas. **Para visualizar as métricas do exemplo de workload do NGINX** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Na região da em que o cluster está em execução, escolha **Metrics** (Métricas) no painel de navegação à esquerda. Encontre o namespace **ContainerInsights/Prometheus** para ver as métricas. 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\$1cluster\$1name*/prometheus**, no fluxo de logs *nginx-plus-prometheus-exporter*. # Tutorial para adicionar um novo destino de extração do Prometheus: Memcached no Amazon ECS Este tutorial fornece uma introdução prática para extrair as métricas do Prometheus de uma amostra de aplicação do Memcached em um cluster do Amazon ECS com o tipo de inicialização do EC2. O destino do exportador do Memcached Prometheus será detectado automaticamente pelo atendente do CloudWatch pela detecção de serviços baseada na definição de tarefa do ECS. O Memcached é um sistema de cache de memória distribuída de uso geral. Geralmente é usado para acelerar sites dinâmicos orientados por banco de dados, armazenando em cache dados e objetos na RAM, a fim de reduzir o número de vezes que uma origem dos dados externa (como um banco de dados ou uma API) precisa ser lida. Para obter mais informações, consulte [O que é Memcached?](https://www.memcached.org/) O [memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (Licença Apache 2.0) é um dos exportadores oficiais do Prometheus. Por padrão, o memcache\$1exporter serve na porta 0.0.0.0:9150 em `/metrics.` As imagens do Docker dos dois repositórios do Docker Hub a seguir são usadas neste tutorial: + [ Memcached](https://hub.docker.com/_/memcached?tab=description) + [ prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/) **Pré-requisito** Para coletar métricas de uma amostra de workload do Prometheus para o Amazon ECS, é necessário estar executando o Container Insights no cluster. Para obter informações sobre como instalar o Container Insights, consulte [Configurar o Container Insights no Amazon ECS](deploy-container-insights-ECS.md). **Topics** + [Definir as variáveis de ambiente de cluster do Amazon ECS EC2](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment) + [Instale a amostra de workload do Memcached](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload) + [Configurar o atendente do CloudWatch para extrair métricas do Memcached Prometheus](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent) + [VIsualizar suas métricas do Memcached](#ContainerInsights-Prometheus-ECS-memcached-view) ## Definir as variáveis de ambiente de cluster do Amazon ECS EC2 **Para definir as variáveis de ambiente de cluster do Amazon ECS EC2** 1. Instale a CLI do Amazon ECS, caso ainda não tenha instalado. Para obter mais informações, consulte: [Instalar a CLI do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html). 1. Defina o novo nome do cluster do Amazon ECS e a região. Por exemplo: ``` ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial AWS_DEFAULT_REGION=ca-central-1 ``` 1. (Opcional) Se ainda não tiver um cluster do Amazon ECS com o tipo de inicialização do EC2 no qual deseja instalar a amostra de workload do Memcached e o atendente do CloudWatch, você pode criar um inserindo o comando a seguir. ``` ecs-cli up --capability-iam --size 1 \ --instance-type t3.medium \ --cluster $ECS_CLUSTER_NAME \ --region $AWS_REGION ``` O resultado esperado desse comando é o seguinte: ``` WARN[0000] You will not be able to SSH into your EC2 instances without a key pair. INFO[0000] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.4 and Docker version 19.03.6-ce INFO[0001] Created cluster cluster=ecs-ec2-memcached-tutorial region=ca-central-1 INFO[0002] Waiting for your cluster resources to be created... INFO[0002] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS INFO[0063] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS INFO[0124] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS VPC created: vpc-xxxxxxxxxxxxxxxxx Security Group created: sg-xxxxxxxxxxxxxxxxx Subnet created: subnet-xxxxxxxxxxxxxxxxx Subnet created: subnet-xxxxxxxxxxxxxxxxx Cluster creation succeeded. ``` ## Instale a amostra de workload do Memcached **Para instalar a amostra de workload do Memcached que expõe as métricas do Prometheus** 1. Baixe o modelo do CloudFormation do Memcached inserindo o comando a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/memcached/memcached-traffic-sample.yaml ``` 1. Defina os nomes da função do IAM a ser criada para o Memcached inserindo os seguintes comandos. ``` MEMCACHED_ECS_TASK_ROLE_NAME=memcached-prometheus-demo-ecs-task-role-name MEMCACHED_ECS_EXECUTION_ROLE_NAME=memcached-prometheus-demo-ecs-execution-role-name ``` 1. Instale a amostra de workload do Memcached inserindo o comando a seguir. Este exemplo instala a workload no modo de rede `host`. ``` MEMCACHED_ECS_NETWORK_MODE=host aws cloudformation create-stack --stack-name Memcached-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MODE \ --template-body file://memcached-traffic-sample.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=ECSNetworkMode,ParameterValue=$MEMCACHED_ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$MEMCACHED_ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$MEMCACHED_ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION ``` A pilha do CloudFormation cria quatro recursos: + Uma função de tarefa do ECS + Uma função de execução de tarefa do ECS + Uma definição de tarefa do Memcached + Um serviço do Memcached Na definição de tarefa do Memcached, são definidos dois contêineres: + O contêiner primário executa uma aplicação do Memcached simples e abre a porta 11211 para acesso. + O outro contêiner executa o processo do exportador do Redis OSS para expor as métricas do Prometheus na porta 9150. É o contêiner a ser detectado e extraído pelo atendente do CloudWatch. ## Configurar o atendente do CloudWatch para extrair métricas do Memcached Prometheus **Para configurar o atendente do CloudWatch para extrair métricas do Memcached Prometheus** 1. Baixe a versão mais recente do arquivo `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` inserindo o comando a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml ``` 1. Abra o arquivo com um editor de textos e encontre a confguração completa do atendente do CloudWatch atrás da chave `value` da seção `resource:CWAgentConfigSSMParameter`. Em seguida, na seção `ecs_service_discovery`, adicione a seguinte configuração na seção `task_definition_list`. ``` { "sd_job_name": "ecs-memcached", "sd_metrics_ports": "9150", "sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+" }, ``` Para a seção `metric_declaration`, a configuração padrão não permite nenhuma métrica do Memcached. Adicione a seção a seguir para permitir métricas do Memcached. Siga o padrão de recuo existente. ``` { "source_labels": ["container_name"], "label_matcher": "memcached-exporter-.*", "dimensions": [["ClusterName", "TaskDefinitionFamily"]], "metric_selectors": [ "^memcached_current_(bytes|items|connections)$", "^memcached_items_(reclaimed|evicted)_total$", "^memcached_(written|read)_bytes_total$", "^memcached_limit_bytes$", "^memcached_commands_total$" ] }, { "source_labels": ["container_name"], "label_matcher": "memcached-exporter-.*", "dimensions": [["ClusterName", "TaskDefinitionFamily","status","command"], ["ClusterName", "TaskDefinitionFamily","command"]], "metric_selectors": [ "^memcached_commands_total$" ] }, ``` 1. Se já tiver o atendente do CloudWatch implantado no cluster do Amazon ECS com o CloudFormation, é possível criar um conjunto de alterações inserindo os comandos a seguir. ``` ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION \ --change-set-name memcached-scraping-support ``` 1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/). 1. Revise o changeset recém-criado `memcached-scraping-support`. Você deverá ver uma alteração aplicada ao recurso `CWAgentConfigSSMParameter`. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo os comandos a seguir. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 0 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Aguarde cerca de 10 segundos e insira este comando. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \ --region $AWS_REGION ``` 1. Se estiver instalando o atendente do CloudWatch com coleta de métricas do Prometheus no cluster pela primeira vez, insira estes comandos: ``` ECS_NETWORK_MODEE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION ``` ## VIsualizar suas métricas do Memcached Este tutorial envia as seguintes métricas ao namespace **ECS/ContainerInsights/Prometheus** no CloudWatch. É possível usar o console do CloudWatch para ver as métricas nesse namespace. | Nome da métrica | Dimensões | | --- | --- | | `memcached_current_items` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_current_connections` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_limit_bytes` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_current_bytes` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_written_bytes_total` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_read_bytes_total` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_items_evicted_total` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_items_reclaimed_total` | `ClusterName`, `TaskDefinitionFamily` | | `memcached_commands_total` | `ClusterName`, `TaskDefinitionFamily` `ClusterName`, TaskDefinitionFamily, comando `ClusterName`, TaskDefinitionFamily, status, comando | **nota** O valor da dimensão **command** pode ser: `delete`, `get`, `cas`, `set`, `decr`, `touch`, `incr` ou `flush`. O valor da dimensão **status** pode ser `hit`, `miss` ou `badval`. Também é possível criar um painel do CloudWatch para suas métricas do Memcached Prometheus. **Para criar um painel para métricas do Memcached Prometheus** 1. Crie variáveis de ambiente, substituindo os valores abaixo para corresponder a sua implantação. ``` DASHBOARD_NAME=your_memcached_cw_dashboard_name ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD ``` 1. Use o comando a seguir para criar o painel. ``` curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json \ | sed "s/{{YOUR_AWS_REGION}}/$AWS_REGION/g" \ | sed "s/{{YOUR_CLUSTER_NAME}}/$ECS_CLUSTER_NAME/g" \ | sed "s/{{YOUR_TASK_DEF_FAMILY}}/$ECS_TASK_DEF_FAMILY/g" \ | xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --region $AWS_REGION --dashboard-body ``` # Tutorial para extração de métricas do Prometheus no Redis OSS no Amazon ECS Fargate Este tutorial apresenta uma introdução prática para extrair as métricas do Prometheus de um exemplo de aplicação do Redis OSS em um cluster do Amazon ECS Fargate. O destino do exportador do Prometheus no Redis OSS será detectado automaticamente pelo agente do CloudWatch com suporte à métrica do Prometheus com base nos rótulos do Docker do contêiner. 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) **Pré-requisito** Para coletar métricas de uma amostra de workload do Prometheus para o Amazon ECS, é necessário estar executando o Container Insights no cluster. Para obter informações sobre como instalar o Container Insights, consulte [Configurar o Container Insights no Amazon ECS](deploy-container-insights-ECS.md). **Topics** + [Definir as variáveis de ambiente de cluster do Amazon ECS Fargate](#ContainerInsights-Prometheus-Setup-redis-ecs-variable) + [Definir as variáveis de ambiente de rede para o cluster do Amazon ECS Fargate](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2) + [Instalar o exemplo de workload do Redis OSS](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload) + [Configurar o agente do CloudWatch para extrair métricas do Prometheus no Redis OSS](#ContainerInsights-Prometheus-Setup-redis-ecs-agent) + [Visualizar suas métricas do Redis OSS](#ContainerInsights-Prometheus-Setup-redis-view) ## Definir as variáveis de ambiente de cluster do Amazon ECS Fargate **Para definir as variáveis de ambiente de cluster do Amazon ECS Fargate** 1. Instale a CLI do Amazon ECS, caso ainda não tenha instalado. Para obter mais informações, consulte: [Instalar a CLI do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html). 1. Defina o novo nome do cluster do Amazon ECS e a região. Por exemplo: ``` ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial AWS_DEFAULT_REGION=ca-central-1 ``` 1. (Opcional) Se ainda não tiver um cluster do Amazon ECS Fargate no qual deseja instalar o exemplo de workload do Redis OSS e o agente do CloudWatch, você pode criar um reproduzindo o comando a seguir. ``` ecs-cli up --capability-iam \ --cluster $ECS_CLUSTER_NAME \ --launch-type FARGATE \ --region $AWS_DEFAULT_REGION ``` O resultado esperado desse comando é o seguinte: ``` INFO[0000] Created cluster cluster=ecs-fargate-redis-tutorial region=ca-central-1 INFO[0001] Waiting for your cluster resources to be created... INFO[0001] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS VPC created: vpc-xxxxxxxxxxxxxxxxx Subnet created: subnet-xxxxxxxxxxxxxxxxx Subnet created: subnet-xxxxxxxxxxxxxxxxx Cluster creation succeeded. ``` ## Definir as variáveis de ambiente de rede para o cluster do Amazon ECS Fargate **Para definir as variáveis de ambiente de rede para o cluster do Amazon ECS Fargate** 1. Defina a VPC e o ID de sub-rede do cluster do Amazon ECS. Se criou um novo cluster no procedimento anterior, você verá esses valores no resultado do comando final. Senão, use os IDs do cluster existente que você usará com o Redis. ``` ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx ``` 1. Neste tutorial, instalaremos a aplicação Redis OSS e o agente do CloudWatch no grupo de segurança padrão da VPC do cluster do Amazon ECS. O grupo de segurança padrão permite qualquer conexão de rede no mesmo grupo de segurança para que o agente do CloudWatch possa extrair as métricas do Prometheus expostas nos contêineres do Redis OSS. Em um ambiente de produção real, convém criar grupos de segurança dedicados para a aplicação do Redis OSS e o agente do CloudWatch, além de definir permissões personalizadas para eles. Para obter o ID do grupo de segurança padrão, insira o comando a seguir. ``` aws ec2 describe-security-groups \ --filters Name=vpc-id,Values=$ECS_CLUSTER_VPC \ --region $AWS_DEFAULT_REGION ``` Em seguida, defina a variável do grupo de segurança padrão do cluster Fargate inserindo o seguinte comando, substituindo *my-default-security-group* pelo valor que você encontrou no comando anterior. ``` ECS_CLUSTER_SECURITY_GROUP=my-default-security-group ``` ## Instalar o exemplo de workload do Redis OSS **Para instalar o exemplo de workload do Redis OSS que expõe as métricas do Prometheus** 1. Baixe o modelo do CloudFormation para Redis OSS inserindo o comando a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml ``` 1. Defina os nomes de perfil do IAM que serão criados para o Redis OSS inserindo os seguintes comandos. ``` REDIS_ECS_TASK_ROLE_NAME=redis-prometheus-demo-ecs-task-role-name REDIS_ECS_EXECUTION_ROLE_NAME=redis-prometheus-demo-ecs-execution-role-name ``` 1. Instale o exemplo de workload do Redis OSS inserindo o comando a seguir. ``` aws cloudformation create-stack --stack-name Redis-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-fargate-awsvpc \ --template-body file://redis-traffic-sample.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \ ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET_1 \ ParameterKey=TaskRoleName,ParameterValue=$REDIS_ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$REDIS_ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_DEFAULT_REGION ``` A pilha do CloudFormation cria quatro recursos: + Uma função de tarefa do ECS + Uma função de execução de tarefa do ECS + Uma definição de tarefa do Redis OSS + Um serviço do Redis OSS A definição de tarefa do Redis OSS define dois contêineres: + O contêiner primário executa uma aplicação simples do Redis OSS e abre a porta 6379 para acesso. + O outro contêiner executa o processo do exportador do Redis OSS para expor as métricas do Prometheus na porta 9121. É o contêiner a ser detectado e extraído pelo atendente do CloudWatch. O rótulo do docker a seguir é definido para que o atendente do CloudWatch possa detectar esse contêiner com base nele. ``` ECS_PROMETHEUS_EXPORTER_PORT: 9121 ``` ## Configurar o agente do CloudWatch para extrair métricas do Prometheus no Redis OSS **Para configurar o agente do CloudWatch para extrair métricas do Prometheus no Redis OSS** 1. Baixe a versão mais recente do arquivo `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` inserindo o comando a seguir. ``` curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml ``` 1. Abra o arquivo com um editor de textos e encontre a confguração completa do atendente do CloudWatch atrás da chave `value` da seção `resource:CWAgentConfigSSMParameter`. Em seguida, na seção `ecs_service_discovery` apresentada aqui, a descoberta de serviços baseada em `docker_label` está habilitada com as configurações padrão que são baseadas em `ECS_PROMETHEUS_EXPORTER_PORT`, que corresponde ao rótulo do Docker estabelecido na definição de tarefa do ECS para Redis OSS. Portanto, não precisamos fazer alterações nesta seção: ``` ecs_service_discovery": { "sd_frequency": "1m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", * "docker_label": { },* ... ``` Para a seção `metric_declaration`, a configuração padrão não permite nenhuma métrica do Redis OSS. Adicione a seção a seguir para permitir métricas do Redis OSS. Siga o padrão de recuo existente. ``` { "source_labels": ["container_name"], "label_matcher": "^redis-exporter-.*$", "dimensions": [["ClusterName","TaskDefinitionFamily"]], "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": ["container_name"], "label_matcher": "^redis-exporter-.*$", "dimensions": [["ClusterName","TaskDefinitionFamily","cmd"]], "metric_selectors": [ "^redis_commands_total$" ] }, { "source_labels": ["container_name"], "label_matcher": "^redis-exporter-.*$", "dimensions": [["ClusterName","TaskDefinitionFamily","db"]], "metric_selectors": [ "^redis_db_keys$" ] }, ``` 1. Se já tiver o atendente do CloudWatch implantado no cluster do Amazon ECS com o CloudFormation, é possível criar um conjunto de alterações inserindo os comandos a seguir. ``` ECS_LAUNCH_TYPE=FARGATE CREATE_IAM_ROLES=True ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1 ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \ --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \ ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \ ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} \ --change-set-name redis-scraping-support ``` 1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/). 1. Revise o changeset recém-criado `redis-scraping-support`. Você deverá ver uma alteração aplicada ao recurso `CWAgentConfigSSMParameter`. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo os comandos a seguir. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 0 \ --service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \ --region ${AWS_DEFAULT_REGION} ``` 1. Aguarde cerca de 10 segundos e insira este comando. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \ --region ${AWS_DEFAULT_REGION} ``` 1. Se estiver instalando o atendente do CloudWatch com coleta de métricas do Prometheus no cluster pela primeira vez, insira estes comandos: ``` ECS_LAUNCH_TYPE=FARGATE CREATE_IAM_ROLES=True ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1 ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \ --template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \ ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \ ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region ${AWS_DEFAULT_REGION} ``` ## Visualizar suas métricas do Redis OSS Este tutorial envia as seguintes métricas ao namespace **ECS/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, `TaskDefinitionFamily` | | `redis_net_output_bytes_total` | ClusterName, `TaskDefinitionFamily` | | `redis_expired_keys_total` | ClusterName, `TaskDefinitionFamily` | | `redis_evicted_keys_total` | ClusterName, `TaskDefinitionFamily` | | `redis_keyspace_hits_total` | ClusterName, `TaskDefinitionFamily` | | `redis_keyspace_misses_total` | ClusterName, `TaskDefinitionFamily` | | `redis_memory_used_bytes` | ClusterName, `TaskDefinitionFamily` | | `redis_connected_clients` | ClusterName, `TaskDefinitionFamily` | | `redis_commands_total` | ` ClusterName`, `TaskDefinitionFamily`, `cmd` | | `redis_db_keys` | `ClusterName`, `TaskDefinitionFamily`, `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 ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc ``` 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" \ ``` # Instalar e configurar a coleta de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes Para coletar métricas do Prometheus de clusters que executam o Amazon EKS ou Kubernetes, é possível usar o atendente do CloudWatch como coletor ou usar o coletor do AWS Distro for OpenTelemetry. Para obter informações sobre como usar o coletor do AWS Distro for OpenTelemetry, consulte [https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus). As seções a seguir explicam como coletar métricas do Prometheus usando o atendente do CloudWatch. Elas explicam como instalar o atendente do CloudWatch com o monitoramento do Prometheus em clusters que executam o Amazon EKS e o Kubernetes e como configurar o atendente para extrair outros destinos. Estas seções também fornecem tutoriais opcionais para configurar amostras de workloads para usar testes com monitoramento do Prometheus. **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.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** + [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" \ ``` # Conversão de tipo de métrica do Prometheus pelo CloudWatch Agent As bibliotecas cliente Prometheus oferecem quatro tipos de métricas principais: + Contador + Medidor + Resumo + Histograma O atendente do CloudWatch oferece suporte aos tipos de métricas de contador, medidor e resumo. As métricas do Prometheus com o tipo de métrica de histograma não compatível são descartadas pelo atendente do CloudWatch. Para obter mais informações, consulte [Registrar as métricas descartadas do Prometheus](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics). **Métricas de medidor** Uma métrica de medidor Prometheus é uma métrica que representa um único valor numérico que pode aumentar e diminuir arbitrariamente. O atendente do CloudWatch extrai métricas de medidor e envia esses valores diretamente. **Métricas de contador** Uma métrica de contador Prometheus é uma métrica cumulativa que representa um único contador que aumenta de forma monotônica cujo valor só pode aumentar ou ser redefinido para zero. O atendente do CloudWatch calcula um delta da extração anterior e envia o valor delta como o valor da métrica no evento de log. Assim, o atendente do CloudWatch começará a produzir um evento de log a partir da segunda extração e continuará com as extrações subsequentes, se houver. **Métricas de resumo** Uma métrica de resumo do Prometheus é um tipo de métrica complexa que é representada por vários pontos de dados. Ela fornece uma contagem total de observações e uma soma de todos os valores observados. Calcula quantis configuráveis sobre uma janela de tempo deslizante. A soma e a contagem de uma métrica resumida são cumulativas, mas os quantis não são. O exemplo a seguir mostra a variância dos quantis. ``` # TYPE go_gc_duration_seconds summary go_gc_duration_seconds{quantile="0"} 7.123e-06 go_gc_duration_seconds{quantile="0.25"} 9.204e-06 go_gc_duration_seconds{quantile="0.5"} 1.1065e-05 go_gc_duration_seconds{quantile="0.75"} 2.8731e-05 go_gc_duration_seconds{quantile="1"} 0.003841496 go_gc_duration_seconds_sum 0.37630427 go_gc_duration_seconds_count 9774 ``` O atendente do CloudWatch lida com a soma e a contagem de uma métrica resumida da mesma forma que lida com métricas de contador, conforme descrito na seção anterior. O atendente do CloudWatch preserva os valores dos quantis conforme eles são originalmente informados. # Métricas do Prometheus coletadas pelo atendente do CloudWatch O atendente do CloudWatch com suporte ao Prometheus coleta automaticamente métricas de vários serviços e workloads. As métricas que são coletadas por padrão estão listadas nas seções a seguir. Você também pode configurar o atendente para coletar mais métricas desses serviços e coletar métricas do Prometheus de outras aplicações e serviços. Para obter mais informações sobre coletar outras métricas, consulte [Configuração do atendente do CloudWatch para o Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config). As métricas da Prometheus coletadas de clusters do Amazon EKS e do Kubernetes estão no namespace **ContainerInsights/Prometheus**. As métricas da Prometheus coletadas de clusters do Amazon ECS estão no namespace **ECS/ContainerInsights/Prometheus**. **Topics** + [Métricas do Prometheus para o App Mesh](#ContainerInsights-Prometheus-metrics-appmesh) + [Métricas do Prometheus para NGINX](#ContainerInsights-Prometheus-metrics-nginx) + [Métricas do Prometheus para Memcached](#ContainerInsights-Prometheus-metrics-memcached) + [Métricas do Prometheus para Java/JMX](#ContainerInsights-Prometheus-metrics-jmx) + [Métricas do Prometheus para HAProxy](#ContainerInsights-Prometheus-metrics-haproxy) ## Métricas do Prometheus para o App Mesh As métricas a seguir são coletadas automaticamente do App Mesh. **Métricas do Prometheus para App Mesh em clusters do Amazon EKS e do Kubernetes** | Nome da métrica | Dimensões | | --- | --- | | `envoy_http_downstream_rq_total` | ClusterName, `Namespace` | | `envoy_http_downstream_rq_xx` | ClusterName, `Namespace` ClusterName, `Namespace`, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class | | `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `Namespace` | | `envoy_cluster_membership_healthy` | ClusterName, `Namespace` | | `envoy_cluster_membership_total` | ClusterName, `Namespace` | | `envoy_server_memory_heap_size` | ClusterName, `Namespace` | | `envoy_server_memory_allocated` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `Namespace` | | `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry_success` | ClusterName, `Namespace` | | `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `Namespace` | | `envoy_server_live` | ClusterName, `Namespace` | | `envoy_server_uptime` | ClusterName, `Namespace` | **Métricas do Prometheus para App Mesh em clusters do Amazon ECS** | Nome da métrica | Dimensões | | --- | --- | | `envoy_http_downstream_rq_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_http_downstream_rq_xx` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_membership_healthy` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_membership_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_memory_heap_size` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_memory_allocated` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_connect_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_pending_overflow` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_rx_reset` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_flow_control_drained_total` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry_success` | ClusterName, `TaskDefinitionFamily` | | `envoy_cluster_upstream_rq_retry_overflow` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_live` | ClusterName, `TaskDefinitionFamily` | | `envoy_server_uptime` | ClusterName, `TaskDefinitionFamily` | | `envoy_http_downstream_rq_xx` | ClusterName, TaskDefinitionFamily, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class ClusterName, TaskDefinitionFamily, envoy\$1response\$1code\$1class | **nota** `TaskDefinitionFamily` é o namespace do Kubernetes da malha. O valor de `envoy_http_conn_manager_prefix` pode ser `ingress`, `egress` ou `admin`. O valor de `envoy_response_code_class` pode ser `1` (significa `1xx`) , `2` (significa `2xx`) ,`3`significa `3xx`), `4` (significa `4xx`) ou `5` (significa`5xx`). ## Métricas do Prometheus para NGINX As métricas a seguir são coletadas automaticamente do NGINX em clusters do Amazon EKS e do Kubernetes. | Nome da métrica | Dimensões | | --- | --- | | `nginx_ingress_controller_nginx_process_cpu_seconds_total` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_success` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_requests` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_nginx_process_connections` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_nginx_process_connections_total` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_nginx_process_resident_memory_bytes` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_config_last_reload_successful` | ClusterName, `Namespace`, serviço | | `nginx_ingress_controller_requests` | ClusterName, `Namespace`, serviço, status | ## Métricas do Prometheus para Memcached As métricas a seguir são coletadas automaticamente do Memcached em clusters do Amazon EKS e do Kubernetes. | Nome da métrica | Dimensões | | --- | --- | | `memcached_current_items` | ClusterName, `Namespace`, serviço | | `memcached_current_connections` | ClusterName, `Namespace`, serviço | | `memcached_limit_bytes` | ClusterName, `Namespace`, serviço | | `memcached_current_bytes` | ClusterName, `Namespace`, serviço | | `memcached_written_bytes_total` | ClusterName, `Namespace`, serviço | | `memcached_read_bytes_total` | ClusterName, `Namespace`, serviço | | `memcached_items_evicted_total` | ClusterName, `Namespace`, serviço | | `memcached_items_reclaimed_total` | ClusterName, `Namespace`, serviço | | `memcached_commands_total` | ClusterName, `Namespace`, serviço ClusterName, `Namespace`, serviço, comando ClusterName, `Namespace`, serviço, status, comando | ## Métricas do Prometheus para Java/JMX **Métricas coletadas em clusters do Amazon EKS e do Kubernetes** Em clusters do Amazon EKS e do Kubernetes, o Container Insights pode coletar as seguintes métricas predefinidas do Prometheus do Java Virtual Machine (JVM), Java e Tomcat (Catalina) usando o JMX Exporter. Para obter mais informações, consulte [ prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) no Github. **Java/JMX em clusters do Amazon EKS e do Kubernetes** | Nome da métrica | Dimensões | | --- | --- | | `jvm_classes_loaded` | `ClusterName`, `Namespace` | | `jvm_threads_current` | `ClusterName`, `Namespace` | | `jvm_threads_daemon` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_processcpuload` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `Namespace` | | `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `Namespace` | | `jvm_memory_bytes_used` | `ClusterName`, `Namespace`, área | | `jvm_memory_pool_bytes_used` | `ClusterName`, `Namespace`, grupo | **nota** Os valores da dimensão `area` podem ser `heap` ou `nonheap`. Os valores da dimensão `pool` podem ser `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` ou `Metaspace`. **Tomcat/JMX em clusters do Amazon EKS e do Kubernetes** Além das métricas Java/JMX na tabela anterior, as métricas a seguir também são coletadas para a workload do Tomcat. | Nome da métrica | Dimensões | | --- | --- | | `catalina_manager_activesessions` | `ClusterName`, `Namespace` | | `catalina_manager_rejectedsessions` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `Namespace` | | `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `Namespace` | **Java/JMX em clusters do Amazon ECS** | Nome da métrica | Dimensões | | --- | --- | | `jvm_classes_loaded` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_threads_current` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_threads_daemon` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_processcpuload` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `TaskDefinitionFamily` | | `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `TaskDefinitionFamily` | | `jvm_memory_bytes_used` | `ClusterName`, TaskDefinitionFamily, área | | `jvm_memory_pool_bytes_used` | `ClusterName`, TaskDefinitionFamily, grupo | **nota** Os valores da dimensão `area` podem ser `heap` ou `nonheap`. Os valores da dimensão `pool` podem ser `Tenured Gen`, `Compress Class Space`, `Survivor Space`, `Eden Space`, `Code Cache` ou `Metaspace`. **Tomcat/JMX em clusters do Amazon ECS** Além das métricas Java/JMX na tabela anterior, as métricas a seguir também são coletadas para a workload do Tomcat em clusters do Amazon ECS. | Nome da métrica | Dimensões | | --- | --- | | `catalina_manager_activesessions` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_manager_rejectedsessions` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `TaskDefinitionFamily` | | `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `TaskDefinitionFamily` | ## Métricas do Prometheus para HAProxy As métricas a seguir são coletadas automaticamente do HAProxy em clusters do Amazon EKS e do Kubernetes. As métricas coletadas dependem da versão do HAProxy Ingress que você está usando. Para obter mais informações sobre o HAProxy Ingress e suas versões, consulte [haproxy-ingress](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress). | Nome da métrica | Dimensões | Disponibilidade | | --- | --- | --- | | `haproxy_backend_bytes_in_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_backend_bytes_out_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_backend_connection_errors_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_backend_connections_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_backend_current_sessions` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_backend_http_responses_total` | `ClusterName`, `Namespace`, Serviço, código, backend | Todas as versões do HAProxy Ingress | | `haproxy_backend_status` | `ClusterName`, `Namespace`, serviço | Somente nas versões 0.10 ou posteriores do HAProxy Ingress | | `haproxy_backend_up` | `ClusterName`, `Namespace`, serviço | Somente nas versões do HAProxy Ingress anteriores à 0.10 | | `haproxy_frontend_bytes_in_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_bytes_out_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_connections_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_current_sessions` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_http_requests_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_http_responses_total` | `ClusterName`, `Namespace`, Serviço, código, frontend | Todas as versões do HAProxy Ingress | | `haproxy_frontend_request_errors_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | | `haproxy_frontend_requests_denied_total` | `ClusterName`, `Namespace`, serviço | Todas as versões do HAProxy Ingress | **nota** Os valores da dimensão `code` podem ser `1xx`, `2xx`, `3xx`, `4xx`, `5xx` ou `other`. Os valores da dimensão `backend` podem ser: `http-default-backend`, `http-shared-backend` ou `httpsback-shared-backend` para HAProxy Ingress versão 0.0.27 ou anteriores. `_default_backend` para versões HAProxy Ingress posteriores a 0.0.27. Os valores da dimensão `frontend` podem ser: `httpfront-default-backend`, `httpfront-shared-frontend` ou `httpfronts` para HAProxy Ingress versão 0.0.27 ou anteriores. `_front_http` ou `_front_https` para versões HAProxy Ingress posteriores a 0.0.27. # Visualizar as métricas do Prometheus Você pode monitorar e utilizar alarmes com todas as métricas do Prometheus, incluindo as métricas selecionadas e pré-agregadas do App Mesh, NGINX, Java/JMX, Memcached e HAProxy, e qualquer outro exportador do Prometheus, configurado manualmente, que você possa ter adicionado. Para obter mais informações sobre como coletar métricas de outros exportadores do Prometheus, consulte [Tutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters). No console do CloudWatch, o Container Insights fornece os seguintes relatórios pré-criados: + Para clusters do Amazon EKS e do Kubernetes, há relatórios pré-criados para App Mesh, NGINX, HAPROXY, Memcached e Java/JMX. + Para clusters do Amazon ECS, há relatórios pré-compilados para App Mesh e Java/JMX. O Container Insights também fornece painéis personalizados para cada uma das workloads das quais o Container Insights coleta métricas selecionadas. É possível baixar esses painéis no GitHub **Como visualizar todas as métricas do Prometheus** 1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, selecione **Métricas**. 1. Na lista de namespaces, escolha **ContainerInsights/Prometheus** or **ECS/ContainerInsights/Prometheus**. 1. Escolha um dos conjuntos de dimensões na lista a seguir. Marque a caixa de seleção ao lado das métricas que você deseja visualizar. **Como visualizar relatórios pré-compilados sobre as métricas do Prometheus** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, selecione **Performance Monitoring (Monitoramento de performance)**. 1. Na caixa suspensa perto da parte superior da página, escolha qualquer uma das opções do Prometheus. Na outra caixa suspensa, escolha um cluster a ser visualizado Também fornecemos painéis personalizados para NGINX, App Mesh, Memcached, HAProxy e Java/JMX. **Como usar um painel personalizado fornecido pela Amazon** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 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 download de um dos arquivos JSON a seguir: + [ Origem do painel personalizado NGINX no Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json). + [ Origem do painel personalizado App Mesh no Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json). + [ Origem do painel personalizado Memcached no Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json) + [ Origem do painel personalizado HAProxy-Ingress no Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json) + [ Origem do painel personalizado Java/JMX no Github](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.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 todos as strings `{{YOUR_REGION}}` pela região da AWS em que o cluster está em execução. Por exemplo, **us-west-1** Não adicione espaços em branco antes ou depois do texto. + Substitua todas as strings `{{YOUR_NAMESPACE}}` pelo namespace exato da workload. + Substitua todas as strings `{{YOUR_SERVICE_NAME}}` pelo nome de serviço exato da workload. Por exemplo, **haproxy-haproxy-ingress-controller-metrics** 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)**. # Solucionar problemas de métricas do Prometheus Esta seção fornece ajuda para solucionar problemas de configuração de métricas do Prometheus. **Topics** + [Solucionar problemas de métricas do Prometheus no Amazon ECS](ContainerInsights-Prometheus-troubleshooting-ECS.md) + [Solucionar problemas de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes](ContainerInsights-Prometheus-troubleshooting-EKS.md) # Solucionar problemas de métricas do Prometheus no Amazon ECS Esta seção fornece ajuda para solucionar problemas de configuração de métricas do Prometheus em clusters do Amazon ECS. ## Não visualizo as métricas do Prometheus enviadas ao CloudWatch Logs As métricas do Prometheus devem ser ingeridas como eventos de log no grupo de logs **/aws/ecs/containerinsights/cluster-name/Prometheus**. Se o grupo de logs não estiver criado ou se as métricas do Prometheus não forem enviadas ao grupo de logs, primeiro você precisará conferir se os destinos do Prometheus foram detectados corretamente pelo atendente do CloudWatch. Em seguida, confira o grupo de segurança e as configurações de permissão do atendente do CloudWatch. As etapas a seguir orientam a fazer a depuração. **Etapa 1: habilitar o modo de depuração do atendente do CloudWatch** Primeiro, altere o atendente do CloudWatch para o modo de depuração adicionando as seguintes linhas em negrito ao modelo de arquivo do CloudFormation: `cwagent-ecs-prometheus-metric-for-bridge-host.yaml` ou `cwagent-ecs-prometheus-metric-for-awsvpc.yaml`. Salve o arquivo. ``` cwagentconfig.json: | { "agent": { "debug": true }, "logs": { "metrics_collected": { ``` Criar um novo changeset do CloudFormation em relação à pilha existente. Defina outros parâmetros do changeset para os mesmos valores de sua pilha do CloudFormation existente. O exemplo a seguir é de um atendente do CloudWatch instalado em um cluster do Amazon ECS usando o tipo de inicialização do EC2 e o modo de rede de ponte. ``` ECS_NETWORK_MODE=bridge CREATE_IAM_ROLES=True ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name NEW_CHANGESET_NAME=your_selected_ecs_execution_role_name aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \ --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \ --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \ ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \ ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \ ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \ ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \ --capabilities CAPABILITY_NAMED_IAM \ --region $AWS_REGION \ --change-set-name $NEW_CHANGESET_NAME ``` Acesse o console do CloudFormation para revisar o novo changeset, `$NEW_CHANGESET_NAME`. Deve haver uma alteração aplicada ao recurso **CWAgentConfigSSMParameter**. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo os comandos a seguir. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 0 \ --service your_service_name_here \ --region $AWS_REGION ``` Aguarde cerca de 10 segundos e insira o comando a seguir. ``` aws ecs update-service --cluster $ECS_CLUSTER_NAME \ --desired-count 1 \ --service your_service_name_here \ --region $AWS_REGION ``` **Etapa 2: verificar os logs de detecção de serviço do ECS** Por padrão, a definição de tarefa do ECS do atendente do CloudWatch habilita os logs na seção abaixo. Os logs são enviados ao CloudWatch Logs no grupo de logs **/ecs/ecs-cwagent-prometheus**. ``` LogConfiguration: LogDriver: awslogs Options: awslogs-create-group: 'True' awslogs-group: "/ecs/ecs-cwagent-prometheus" awslogs-region: !Ref AWS::Region awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc' ``` Filtrar os logs pela string `ECS_SD_Stats` para obter as métricas relacionadas à detecção de serviços do ECS, conforme mostrado no exemplo a seguir. ``` 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1 2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2 2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms ``` O significado de cada métrica para determinado ciclo de detecção de serviços do ECS é o seguinte: + **AWSCLI\$1DescribeContainerInstances**: o número de chamadas de API `ECS::DescribeContainerInstances` realizadas. + **AWSCLI\$1DescribeInstancesRequest**: o número de chamadas de API `ECS::DescribeInstancesRequest` realizadas. + **AWSCLI\$1DescribeTaskDefinition**: o número de chamadas de API `ECS::DescribeTaskDefinition` realizadas. + **AWSCLI\$1DescribeTasks**: o número de chamadas de API `ECS::DescribeTasks` realizadas. + **AWSCLI\$1ListTasks**: o número de chamadas de API `ECS::ListTasks` realizadas. + **ExporterDiscoveredTargetCount**: o número de destinos do Prometheus que foram detectados e exportados corretamente para o arquivo de resultados de destino dentro do contêiner. + **LRUCache\$1Get\$1EC2MetaData**: o número de vezes em que os metadados de instâncias de contêiner foram recuperados do cache. + **LRUCache\$1Get\$1TaskDefinition**: o número de vezes que os metadados de definição de tarefa do ECS foram recuperados do cache. + **LRUCache\$1Size\$1ContainerInstance**: o número de metadados da instância de contêiner exclusiva armazenados em cache na memória. + **LRUCache\$1Size\$1TaskDefinition**: o número de definições de tarefa de ECS exclusivas armazenadas em cache na memória. + **Latency**: quanto tempo demora o ciclo de detecção de serviços. Confira o valor de `ExporterDiscoveredTargetCount` para ver se os destinos detectados do Prometheus correspondem a suas expectativas. Caso contrário, os possíveis motivos são: + A configuração da detecção de serviços do ECS pode não corresponder à configuração de sua aplicação. Para a detecção de serviços baseada em rótulos do docker, seus contêineres de destino talvez não tenham o rótulo do docker necessário configurado no atendente do CloudWatch para detectá-los automaticamente. Para a detecção de serviços baseada em expressão regular do ARN da definição de tarefa do ECS, a configuração regex no atendente do CloudWatch pode não corresponder à definição de tarefa da aplicação. + A função da tarefa do ECS do atendente do CloudWatch pode não ter permissão para recuperar os metadados das tarefas do ECS. Verifique se o atendente do CloudWatch recebeu as seguintes permissões somente para leitura: + `ec2:DescribeInstances` + `ecs:ListTasks` + `ecs:DescribeContainerInstances` + `ecs:DescribeTasks` + `ecs:DescribeTaskDefinition` **Etapa 3: verificar a conexão de rede e a política de função de tarefa do ECS** Se ainda não houver eventos de log enviados ao grupo de logs do CloudWatch Logs de destino, mesmo que o valor de `Exporter_DiscoveredTargetCount` indique que há destinos do Prometheus detectados, isso pode ser causado por uma destas situações: + O atendente do CloudWatch talvez não consiga se conectar às portas de destino do Prometheus. Verifique a configuração do grupo de segurança por trás do atendente do CloudWatch. O IP privado deve permitir que o atendente do CloudWatch se conecte às portas do exportador do Prometheus. + A função da tarefa do ECS do atendente do CloudWatch talvez não tenha a política gerenciada **CloudWatchAgentServerPolicy**. A função da tarefa do ECS do atendente do CloudWatch precisa ter essa política para poder enviar as métricas do Prometheus como eventos de log. Se você usou o modelo do CloudFormation para criar as funções do IAM automaticamente, tanto a função da tarefa do ECS como a função de execução do ECS são concedidas com o menor privilégio para executar o monitoramento do Prometheus. # Solucionar problemas de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes Esta seção fornece ajuda para solucionar problemas de configuração de métricas do Prometheus em clusters do Amazon EKS e do Kubernetes. ## Etapas gerais de solução de problemas no Amazon EKS Insira o comando a seguir para confirmar se o atendente do CloudWatch está em execução. ``` kubectl get pod -n amazon-cloudwatch ``` A saída deve incluir uma linha com `cwagent-prometheus-id` na coluna `NAME`, e `Running` no campo `STATUS column.` Para exibir detalhes sobre o pod em execução, insira o comando a seguir. Substitua o *pod-name* pelo nome completo do pod que tem o nome que começa com `cw-agent-prometheus`. ``` kubectl describe pod pod-name -n amazon-cloudwatch ``` Se você tiver o CloudWatch Container Insights instalado, poderá usar o CloudWatch Logs Insights para consultar os logs do atendente do CloudWatch que coleta as métricas do Prometheus. **Como consultar os logs do aplicativo** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, em Logs, escolha **CloudWatch Logs Insights**. 1. Selecione o grupo de logs para os logs do aplicativo, **/aws/containerinsights/*cluster-name*/application** 1. Substitua a expressão de consulta de pesquisa pela seguinte consulta e escolha **Run query (Executar consulta)** ``` fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log | filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus ``` Você também pode confirmar se as métricas e os metadados do Prometheus estão sendo ingeridos como eventos do CloudWatch Logs. **Como confirmar se os dados do Prometheus estão sendo ingeridos** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, em Logs, escolha **CloudWatch Logs Insights**. 1. Selecione **/aws/containerinsights/*cluster-name*/prometheus** 1. Substitua a expressão de consulta de pesquisa pela seguinte consulta e escolha **Run query (Executar consulta)** ``` fields @timestamp, @message | sort @timestamp desc | limit 20 ``` ## Registrar as métricas descartadas do Prometheus Essa versão não coleta métricas do Prometheus do tipo histograma. Você pode usar o atendente do CloudWatch para verificar se alguma métrica do Prometheus está sendo descartada por ser de uma métrica de histograma. Também é possível registrar em log uma lista das primeiras 500 métricas do Prometheus que forem descartadas e não enviadas ao CloudWatch por serem métricas de histograma. Para ver se alguma métrica está sendo descartada, insira o comando a seguir: ``` kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1 ``` Se alguma métrica estiver sendo descartada, você verá as seguintes linhas no arquivo `/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log`. ``` I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported. I! Please enable CWAgent debug mode to view the first 500 dropped metrics ``` Se você vir essas linhas e quiser saber quais métricas estão sendo descartadas, siga as etapas a seguir. **Como registrar em log uma lista de métricas descartadas do Prometheus** 1. Altere o atendente do CloudWatch para o modo de depuração adicionando as seguintes linhas em negrito ao arquivo `prometheus-eks.yaml` ou `prometheus-k8s.yaml` e salve o arquivo. ``` { "agent": { "debug": true }, ``` Esta seção do arquivo deve ser semelhante ao seguinte: ``` cwagentconfig.json: | { "agent": { "debug": true }, "logs": { "metrics_collected": { ``` 1. Reinstale o atendente do CloudWatch para habilitar o modo de depuração inserindo os comandos a seguir: ``` kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch kubectl apply -f prometheus.yaml ``` As métricas descartadas são registradas no pod do atendente do CloudWatch. 1. Para recuperar os logs do pod do atendente do CloudWatch, insira o comando a seguir: ``` kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1 ``` Ou, se você tiver a geração de logs do Fluentd do Container Insights instalada, os logs também serão salvos no grupo de logs do CloudWatch Logs **/aws/containerinsights/*cluster\$1name*/application**. Para consultar esses logs, você pode seguir as etapas para consultar os logs do aplicativo em [Etapas gerais de solução de problemas no Amazon EKS](#ContainerInsights-Prometheus-troubleshooting-general). ## Onde estão as métricas do Prometheus ingeridas como eventos de log do CloudWatch Logs? O atendente do CloudWatch cria um fluxo de logs para cada configuração do trabalho de extração do Prometheus. Por exemplo, nos arquivos `prometheus-eks.yaml` e `prometheus-k8s.yaml`, a linha `job_name: 'kubernetes-pod-appmesh-envoy'` extrai conteúdo de métricas do App Mesh. O alvo do Prometheus é definido como `kubernetes-pod-appmesh-envoy`. Portanto, todas as métricas do App Mesh Prometheus são ingeridas como eventos do CloudWatch Logs no fluxo de logs **kubernetes-pod-appmesh-envoy** no grupo de logs chamado **/aws/containerinsights/cluster-name/Prometheus**. ## Não visualizo métricas do Amazon EKS ou do Kubernetes Prometheus nas métricas do CloudWatch Primeiro, verifique se as métricas do Prometheus são ingeridas como eventos de log no grupo de logs **/aws/containerinsights/cluster-name/Prometheus**. Use as informações em [Onde estão as métricas do Prometheus ingeridas como eventos de log do CloudWatch Logs?](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested) para ajudar a verificar o fluxo de logs de destino. Se o fluxo de logs não foi criado ou não houver novos eventos de log no fluxo de logs, confira o seguinte: + Verifique se os endpoints do exportador de métricas do Prometheus estão configurados corretamente + Verifique se as configurações de extração de conteúdo do Prometheus na seção `config map: cwagent-prometheus` do arquivo YAML do atendente do CloudWatch estão corretas. A configuração deve ser a mesma de um arquivo de configuração do Prometheus. Para obter mais informações, consulte [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) na documentação do Prometheus. Se as métricas do Prometheus foram corretamente ingeridas como eventos de log, verifique se as configurações de formato de métrica incorporadas foram adicionadas aos eventos de log para gerar as métricas do CloudWatch. ``` "CloudWatchMetrics":[ { "Metrics":[ { "Name":"envoy_http_downstream_cx_destroy_remote_active_rq" } ], "Dimensions":[ [ "ClusterName", "Namespace" ] ], "Namespace":"ContainerInsights/Prometheus" } ], ``` Para obter mais informações sobre o formato de métrica incorporado, consulte [Especificação: formato de métricas incorporadas](CloudWatch_Embedded_Metric_Format_Specification.md). Se não houver nenhum formato de métrica incorporado nos eventos de log, verifique se a seção `metric_declaration` está configurada corretamente na seção `config map: prometheus-cwagentconfig` do arquivo YAML de instalação do atendente do CloudWatch. Para obter mais informações, consulte [Tutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters).