

# Usar o atendente do CloudWatch para enviar logs de formato de métricas incorporadas
<a name="CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent"></a>

 Esta seção descreve como instalar e usar o agente do CloudWatch. Na primeira parte desta seção, é abordado como instalar o agente do CloudWatch. Na segunda parte desta seção, é explicado como usar o agente do CloudWatch para enviar logs no formato de métricas incorporadas. Caso deseje usar este método, é necessário instalar o agente do CloudWatch para os Serviços da AWS dos quais deseja enviar logs no formato de métricas incorporadas. Em seguida, você pode começar a enviar os eventos. O atendente do CloudWatch deve ser da versão 1.230621.0 ou posterior.

**nota**  
Não é necessário instalar o atendente do CloudWatch para enviar logs de funções do Lambda.  
Os tempos limite da função do Lambda não são processados automaticamente. Isso significa que se a função atingir o tempo limite antes de as métricas serem liberadas, as métricas dessa invocação não serão capturadas.

## Instalação do atendente do CloudWatch
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent"></a>

Instale o atendente do CloudWatch para cada serviço que ´deve enviar logs de formato de métrica incorporado.

### Instalar o atendente do CloudWatch no EC2
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_EC2"></a>

Primeiro, instale o atendente do CloudWatch na instância. Para obter mais informações, consulte [Instalação do atendente do CloudWatch](install-CloudWatch-Agent-on-EC2-Instance.md).

Após instalar o atendente, configure-o para escutar em uma porta UDP ou TCP para os logs de formato de métricas incorporadas. Veja a seguir um exemplo dessa configuração que escuta no soquete padrão `tcp:25888`. Para obter mais informações sobre a configuração do atendente, consulte [Criar ou editar manualmente o arquivo de configuração do atendente do CloudWatch](CloudWatch-Agent-Configuration-File-Details.md).

```
{
  "logs": {
    "metrics_collected": {
      "emf": { }
    }
  }
}
```

### Instalar o atendente do CloudWatch no Amazon ECS
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_ECS"></a>

A maneira mais fácil de implantar o atendente do CloudWatch no Amazon ECS é executá-lo como um arquivo associado, definindo-o na mesma definição de tarefa da aplicação.

**Criar um arquivo de configuração do atendente**

Crie o arquivo de configuração do atendente do CloudWatch localmente. Neste exemplo, o caminho do arquivo relativo será `amazon-cloudwatch-agent.json`.

Para obter mais informações sobre a configuração do atendente, consulte [Criar ou editar manualmente o arquivo de configuração do atendente do CloudWatch](CloudWatch-Agent-Configuration-File-Details.md).

```
{
  "logs": {
    "metrics_collected": {
      "emf": { }
    }
  }
}
```

**Enviar configuração para o SSM Parameter Store **

Insira o comando a seguir para enviar o arquivo de configuração do atendente do CloudWatch ao AWS Systems Manager (SSM) Parameter Store.

```
aws ssm put-parameter \
    --name "cwagentconfig" \
    --type "String" \
    --value "`cat amazon-cloudwatch-agent.json`" \
    --region "{{region}}"
```

**Configurar a definição da tarefa**

Configure a definição de tarefa para usar o atendente do CloudWatch e expor a porta TCP ou UDP. A definição de tarefa de amostra que você deve usar depende do modo de rede.

Observe que o `webapp` especifica a variável de ambiente `AWS_EMF_AGENT_ENDPOINT`. Isso é usado pela biblioteca e deve apontar para o endpoint no qual o atendente está escutando. Além disso, o `cwagent` especifica o `CW_CONFIG_CONTENT` como um parâmetro “valueFrom” que aponta para a configuração do SSM criada na etapa anterior.

Esta seção contém um exemplo para o modo ponte e um exemplo para o modo host ou awsvpc. Para obter mais exemplos de como configurar o atendente do CloudWatch no Amazon ECS, consulte o [Repositório de exemplos do Github](https://github.com/aws-samples/amazon-cloudwatch-container-insights/tree/master/ecs-task-definition-templates/deployment-mode/sidecar)

Veja a seguir um exemplo do modo de ponte. Quando o modo de ponte de redes está habilitado, o atendente precisa estar vinculado à aplicação usando o parâmetro `links` e deve ser abordado usando o nome do contêiner.

```
{
  "containerDefinitions": [
          {
              "name": "webapp",
              "links": [ "cwagent" ],
              "image": "my-org/web-app:latest",
              "memory": 256,
              "cpu": 256,
              "environment": [{
                "name": "AWS_EMF_AGENT_ENDPOINT",
                "value": "tcp://cwagent:25888"
              }],
          },
          {
              "name": "cwagent",
              "mountPoints": [],
              "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest",
              "memory": 256,
              "cpu": 256,
              "portMappings": [{
                  "protocol": "tcp",
                  "containerPort": 25888
              }],
              "environment": [{
                "name": "CW_CONFIG_CONTENT",
                "valueFrom": "cwagentconfig"
              }],
          }
      ],
}
```

Veja a seguir um exemplo do modo de host ou modo awsvpc. Ao executar esses modos de rede, o atendente pode ser abordado como `localhost`.

```
{
  "containerDefinitions": [
          {
              "name": "webapp",
              "image": "my-org/web-app:latest",
              "memory": 256,
              "cpu": 256,
              "environment": [{
                "name": "AWS_EMF_AGENT_ENDPOINT",
                "value": "tcp://127.0.0.1:25888"
              }],
          },
          {
              "name": "cwagent",
              "mountPoints": [],
              "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest",
              "memory": 256,
              "cpu": 256,
              "portMappings": [{
                  "protocol": "tcp",
                  "containerPort": 25888
              }],
              "environment": [{
                "name": "CW_CONFIG_CONTENT",
                "valueFrom": "cwagentconfig"
              }],
          }
      ],
}
```

**nota**  
No modo awsvpc, é necessário atribuir um endereço IP público à VPC (somente Fargate), configurar um gateway NAT ou definir um endpoint da VPC do CloudWatch Logs. Para obter mais informações sobre como configurar um NAT, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). Para obter mais informações sobre como configurar um endpoint da VPC do CloudWatch Logs,consulte [Usar o CloudWatch Logs com endpoints da VPC de interface](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html).  
Veja a seguir um exemplo de como atribuir um endereço IP público a uma tarefa que usa o tipo de inicialização do Fargate.  

```
aws ecs run-task \ 
--cluster {{cluster-name}} \
--task-definition cwagent-fargate \
--region {{region}} \
--launch-type FARGATE \
--network-configuration "awsvpcConfiguration={subnets=[{{subnetId}}],securityGroups=[{{sgId}}],assignPublicIp=ENABLED}"
```

**Verificar permissões**

Verifique se a função do IAM que está executando as tarefas tem permissão para ler do SSM Parameter Store. É possível adicionar essa permissão anexando a política **AmazonSSMReadOnlyAccess**. Para fazer isso, insira o comando a seguir.

```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess \
--role-name CWAgentECSExecutionRole
```

### Instalar o atendente do CloudWatch no Amazon EKS
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_EKS"></a>

Partes desse processo podem ser puladas caso o CloudWatch Container Insights já esteja instalado nesse cluster.

Permissões

Se você ainda não instalou o Container Insights, primeiro verifique se os nós do Amazon EKS têm as permissões do IAM apropriadas. Eles devem ter a **CloudWatchAgentServerPolicy** anexada. Para obter mais informações, consulte [Verificação dos pré-requisitos para o Container Insights no CloudWatch](Container-Insights-prerequisites.md).

**Criar ConfigMap**

Criar um ConfigMap para o atendente O ConfigMap também informa ao atendente para escutar em uma porta TCP ou UDP. Use o ConfigMap a seguir.

```
# cwagent-emf-configmap.yaml
apiVersion: v1
data:
  # Any changes here must not break the JSON format
  cwagentconfig.json: |
    {
      "agent": {
        "omit_hostname": true
      },
      "logs": {
        "metrics_collected": {
          "emf": { }
        }
      }
    }
kind: ConfigMap
metadata:
  name: cwagentemfconfig
  namespace: default
```

Se o Container Insights já estiver instalado, adicione a linha `"emf": { }` a seguir ao ConfigMap existente.

**Aplicar o ConfigMap**

Insira o comando a seguir para aplicar o ConfigMap.

```
kubectl apply -f cwagent-emf-configmap.yaml
```

**Implantar o atendente**

Para implantar o atendente do CloudWatch como um arquivo associado, adicione o atendente à definição do pod, conforme o exemplo a seguir.

```
apiVersion: v1
kind: Pod
metadata:
  name: myapp
  namespace: default
spec:
  containers:
    # Your container definitions go here
    - name: web-app
      image: my-org/web-app:latest
    # CloudWatch Agent configuration
    - name: cloudwatch-agent
      image: public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest
      imagePullPolicy: Always
      resources:
        limits:
          cpu: 200m
          memory: 100Mi
        requests:
          cpu: 200m
          memory: 100Mi
      volumeMounts:
        - name: cwagentconfig
          mountPath: /etc/cwagentconfig
      ports:
  # this should match the port configured in the ConfigMap
        - protocol: TCP
          hostPort: 25888
          containerPort: 25888
  volumes:
    - name: cwagentconfig
      configMap:
        name: cwagentemfconfig
```

## Usar o atendente do CloudWatch para enviar logs de formato de métricas incorporadas
<a name="CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent_Send_Logs"></a>

Após instalar e executar o atendente do CloudWatch, é possível enviar logs de formato de métrica incorporado por TCP ou UDP. Há dois requisitos ao enviar os logs pelo atendente:
+ Os logs devem conter uma chave `LogGroupName` que informa ao atendente qual grupo de logs deve ser usado.
+ Cada evento de log deve estar em uma única linha. Em outras palavras, um evento de log não pode conter o caractere de nova linha (\\n).

Os eventos de log também devem seguir a especificação do formato de métricas incorporadas. Para obter mais informações, consulte [Especificação: formato de métricas incorporadas](CloudWatch_Embedded_Metric_Format_Specification.md).

Se você planeja criar alarmes em métricas criadas usando o formato de métricas incorporadas, consulte [Configuração de alarmes em métricas criadas com o formato de métricas incorporadas](CloudWatch_Embedded_Metric_Format_Alarms.md) para obter as recomendações.

Veja a seguir um exemplo de como enviar eventos de log manualmente de um shell bash do Linux. Em vez disso, é possível usar as interfaces de soquete UDP fornecidas pela linguagem de programação da sua escolha. 

```
echo '{"_aws":{"Timestamp":1574109732004,"LogGroupName":"Foo","CloudWatchMetrics":[{"Namespace":"MyApp","Dimensions":[["Operation"]],"Metrics":[{"Name":"ProcessingLatency","Unit":"Milliseconds","StorageResolution":60}]}]},"Operation":"Aggregator","ProcessingLatency":100}' \
> /dev/udp/0.0.0.0/25888
```

**nota**  
 Com o formato de métrica incorporada, você pode acompanhar o processamento de seus logs de EMF por métricas publicadas no namespace `AWS/Logs` da conta. Podem ser usados para rastrear falhas na geração de métricas do EMF, bem como se as falhas ocorrem devido à análise ou validação. Para obter mais informações, consulte [Monitorar com métricas do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). 