# 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" \
```