# Tutorial para extração de métricas do Prometheus no Redis OSS no Amazon ECS Fargate
<a name="ContainerInsights-Prometheus-Setup-redis-ecs"></a>

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\_exporter (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\_exporter](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\_exporter](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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-variable2"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-install-workload"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-ecs-agent"></a>

**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
<a name="ContainerInsights-Prometheus-Setup-redis-view"></a>

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