# Introdução
Para começar a usar o OpenTelemetry no CloudWatch, você pode usar a configuração pré-empacotada do OpenTelemetry que está disponível com o agente do CloudWatch junto com os SDKs do AWS Distro para OpenTelemetry. Isso proporciona a experiência de monitoramento mais integrada no CloudWatch.
**nota**
Certifique-se de que a Pesquisa de transações esteja habilitada antes de usar o endpoint do OTLP para rastreamentos.
Como alternativa, você tem a flexibilidade de usar o OpenTelemetry Collector ou seu próprio OpenTelemetry Collector personalizado para enviar telemetria diretamente para o endpoint do OTLP. Você pode usar o AWS Distro para OpenTelemetry para operar sem coletor e enviar telemetria diretamente para o endpoint do OTLP. Faça uma escolha informada com base na compatibilidade de recursos:
| Recurso | Coletor do OpenTelemetry | OpenTelemetry Collector personalizado | AWS Distro para OpenTelemetry |
| --- | --- | --- | --- |
| CloudWatch Application Signals (métricas de performance da aplicação, descoberta de serviços e mapa da aplicação) | Sim | Sim | Sim |
| Pesquisar e analisar resumos de rastreamentos e extensões | Sim | Sim | Sim |
| Pesquisar e analisar resumos de logs | Sim | Sim | Sim |
| Enriquecimento da telemetria de monitoramento de performance de aplicações com atributos da infraestrutura da AWS, na qual a aplicação está hospedada. | Não | Sim | Sim |
| Métricas de runtime correlacionadas com a aplicação. Por exemplo, métricas da JVM | Não | Sim | Não |
| AWSSuporte a | Dados recebidos pela AWS | Dados recebidos pela AWS | Dados recebidos pela AWS |
| Suporte para telemetria | Logs, métricas, rastreamentos | Logs, Rastreamentos, Métricas | Métricas, rastreamentos |
**Topics**
+ [Coletor do OpenTelemetry](CloudWatch-OTLPSimplesetup.md)
+ [Criar seu próprio OpenTelemetry Collector](CloudWatch-OTLPAdvancedsetup.md)
+ [Exportação de telemetria sem coletor usando o AWS Distro para OpenTelemetry (ADOT)](CloudWatch-OTLP-UsingADOT.md)
+ [Habilitação de métricas fornecidas no PromQL](CloudWatch-OTelEnrichment.md)
# Coletor do OpenTelemetry
O OpenTelemetry Collector é um agente de código aberto, independente de fornecedor, que recebe, processa e exporta dados de telemetria. Ele atua como um pipeline central entre suas aplicações e o Amazon CloudWatch, coletando métricas, logs e rastreamentos de várias fontes e enviando-os para o CloudWatch usando o OpenTelemetry Protocol (OTLP).
Usar o OpenTelemetry Collector com o CloudWatch oferece os seguintes benefícios:
+ Colete telemetria de várias aplicações e hosts por meio de um único agente, reduzindo o número de conexões com o CloudWatch.
+ Processe e filtre a telemetria antes de enviá-la ao CloudWatch, incluindo adicionar ou remover atributos, agrupar dados em lotes e rastrear amostras.
+ Use a mesma configuração de coletor em ambientes on-premises, da AWS e outros de nuvem, fornecendo um pipeline de telemetria consistente, independentemente de onde suas aplicações sejam executadas.
+ Envie métricas para o CloudWatch com rótulos ricos que estão disponíveis para consulta usando ao Prometheus Query Language (PromQL) no CloudWatch Query Studio.
## Receptores compatíveis
O OpenTelemetry Collector é compatível com uma ampla variedade de receptores para ingestão de dados de telemetria. Você pode usar receptores do OpenTelemetry, como o receptor do OTLP, para aplicações instrumentadas com OpenTelemetry SDKs, ou receptores do Prometheus, para extrair métricas de exportadores existentes do Prometheus. Os receptores comuns do Prometheus usados com o CloudWatch incluem:
+ Receptor do Prometheus, para extrair qualquer endpoint compatível com o Prometheus
+ Receptor de métricas do host, para coletar métricas em nível de sistema do host
+ Receptor de clusters do Kubernetes, para coletar métricas em nível de cluster do servidor da API do Kubernetes
Você pode configurar vários receptores em um único coletor, o que permite coletar as métricas do OpenTelemetry e do Prometheus e enviá-las ao CloudWatch por meio do mesmo pipeline. Para ver a lista completa dos receptores disponíveis, consulte o [repositório](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver) do OpenTelemetry Collector.
## Introdução
Pré-requisito: se for usar o endpoint do OTLP para rastreamento, certifique-se de que a Pesquisa de transações esteja habilitada.
Etapas:
1. Faça o download da versão mais recente da distribuição do OpenTelemetry Collector. Para obter mais informações, consulte as [versões](https://github.com/open-telemetry/opentelemetry-collector-releases/releases) do OpenTelemetry Collector.
1. Instale o OpenTelemetry Collector no seu host. O coletor é executado em qualquer plataforma e sistema operacional. Para obter mais informações, consulte [Install the Collector](https://opentelemetry.io/docs/collector/installation/).
1. Configure as credenciais da AWS no host do Amazon EC2 ou on-premises. O coletor usa essas credenciais para se autenticar com o CloudWatch ao enviar dados de telemetria. Consulte abaixo para obter detalhes.
------
#### [ Setup IAM permissions for Amazon EC2 ]
**Siga o procedimento abaixo para anexar a política `CloudWatchAgentServerPolicy` do IAM ao perfil do IAM da instância do Amazon EC2.**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e localize e selecione o perfil usado pela instância do Amazon EC2.
1. Na guia **Permissões**, escolha **Adicionar permissões** e **Anexar políticas**.
1. Usando a caixa de pesquisa, pesquise a política `CloudWatchAgentServerPolicy`.
1. Selecione a política **CloudWatchAgentServerPolicy** e escolha **Adicionar permissões**.
------
#### [ Setup IAM permissions for on-premise hosts ]
**Você pode criar o usuário do IAM a ser usado para fornecer permissões aos hosts on-premises.**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Usuários**, **Criar usuário**.
1. Em **Detalhes do usuário**, em **Nome do usuário**, insira um nome para o novo usuário do IAM. Esse é o nome de login para a AWS que será usado para autenticar seu host.
1. Escolha **Próximo**.
1. Na página **Definir permissões**, em **Opções de permissões**, escolha **Anexar políticas diretamente**.
1. Na lista de **Políticas de permissões**, selecione a política **CloudWatchAgentServerPolicy** para adicionar ao seu usuário.
1. Escolha **Próximo**.
1. Na página **Revisar e criar**, certifique-se de que você está satisfeito com o nome de usuário e que a política **CloudWatchAgentServerPolicy** está no **Resumo de permissões**.
1. Selecione **Criar usuário**.
1. **Crie e recupere a chave secreta e a chave de acesso da AWS**: no painel de navegação do console do IAM, escolha **Usuários** e depois selecione o nome do usuário do usuário que você criou na etapa anterior.
1. Na página do usuário, escolha a guia **Credenciais de segurança**.
1. Na seção **Chaves de acesso**, escolha **Criar chave de acesso**.
1. Em **Criar chave de acesso: etapa 1**, escolha **Command Line Interface (CLI)**.
1. Em **Criar chave de acesso: etapa 2**, insira uma tag opcional e escolha **Próximo**.
1. Em **Criar chave de acesso: etapa 3**, selecione **Baixar arquivo .csv** para salvar um arquivo .csv com a chave de acesso e a chave de acesso secreta do usuário do IAM. Você precisará dessas informações para as próximas etapas.
1. Selecione **Concluído**.
1. Configure suas credenciais da AWS no host on-premises ao inserir o comando a seguir. Substitua *ACCESS\$1KEY\$1ID* e *SECRET\$1ACCESS\$1ID* pela chave de acesso recém-gerada e pela chave de acesso secreta do arquivo .csv que você baixou na etapa anterior.
```
$ aws configure
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json
```
------
1. Configure as credenciais da AWS para os clusters do Amazon EKS ou do Kubernetes. A maneira mais fácil de começar a usar o Amazon EKS é usar o complemento EKS OTel Container Insights. Se preferir usar o OpenTelemetry Collector diretamente, siga o procedimento abaixo para configurar as credenciais da AWS para os clusters do Amazon EKS ou do Kubernetes para enviar telemetria para o CloudWatch.
------
#### [ Setup IAM permissions for Amazon EKS ]
1. Crie um provedor de identidade OIDC do IAM para o cluster com o comando a seguir.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} --region ${REGION} --approve
```
1. Atribua perfis do IAM à conta de serviço do Kubernetes para o OTel Collector usando o comando a seguir.
```
eksctl create iamserviceaccount \
--name ${COLLECTOR_SERVICE_ACCOUNT}\
--namespace ${NAMESPACE} \
--cluster ${CLUSTER_NAME} \
--region ${REGION} \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
------
#### [ Setup IAM permissions for Kubernetes ]
1. Configure suas credenciais da AWS no host on-premises ao inserir o comando a seguir. Substitua *ACCESS\$1KEY\$1ID* e *SECRET\$1ACCESS\$1ID* pela chave de acesso recém-gerada e pela chave de acesso secreta do arquivo .csv que você baixou na etapa anterior. Por padrão, o arquivo de credenciais é salvo em */home/user/.aws/credentials*.
```
aws configure
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json
```
1. Edite o recurso OpenTelemetry Collector para adicionar o segredo de credenciais da AWS recém-criado usando o seguinte comando: `kubectl edit OpenTelemetryCollector otel_collector`
1. Usando o editor de arquivos, inclua as credenciais da AWS no contêiner do OpenTelemetryCollector adicionando a configuração a seguir na parte superior da implantação. Substitua o caminho */home/user/.aws/credentials* pelo local do seu arquivo local de credenciais da AWS.
```
spec:
volumeMounts:
- mountPath: /rootfs
volumeMounts:
- name: aws-credentials
mountPath: /root/.aws
readOnly: true
volumes:
- hostPath:
path: /home/user/.aws/credentials
name: aws-credentials
```
------
1. Configure o exportador do OTLP na configuração do coletor para enviar telemetria ao endpoint do CloudWatch. Veja exemplos abaixo.
## Exemplos de configuração do coletor
Copie e cole o conteúdo abaixo para configurar o coletor com o objetivo de enviar logs e rastreamentos ao endpoint do OTLP.
```
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
otlphttp/logs:
compression: gzip
logs_endpoint: logs_otlp_endpoint
headers:
x-aws-log-group: ency_log_group
x-aws-log-stream: default
auth:
authenticator: sigv4auth/logs
otlphttp/traces:
compression: gzip
traces_endpoint: traces_otlp_endpoint
auth:
authenticator: sigv4auth/traces
extensions:
sigv4auth/logs:
region: "region"
service: "logs"
sigv4auth/traces:
region: "region"
service: "xray"
service:
telemetry:
extensions: [sigv4auth/logs, sigv4auth/traces]
pipelines:
logs:
receivers: [otlp]
exporters: [otlphttp/logs]
traces:
receivers: [otlp]
exporters: [otlphttp/traces]
```
Veja a seguir um exemplo de como enviar logs e rastreamentos usando sigv4 para us-east-1.
```
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
otlphttp/logs:
compression: gzip
logs_endpoint: https://logs.us-east-1.amazonaws.com/v1/logs
headers:
x-aws-log-group: MyApplicationLogs
x-aws-log-stream: default
auth:
authenticator: sigv4auth/logs
otlphttp/traces:
compression: gzip
traces_endpoint: https://xray.us-east-1.amazonaws.com/v1/traces
auth:
authenticator: sigv4auth/traces
extensions:
sigv4auth/logs:
region: "us-east-1"
service: "logs"
sigv4auth/traces:
region: "us-east-1"
service: "xray"
service:
telemetry:
extensions: [sigv4auth/logs, sigv4auth/traces]
pipelines:
logs:
receivers: [otlp]
exporters: [otlphttp/logs]
traces:
receivers: [otlp]
exporters: [otlphttp/traces]
```
**nota**
Configure os SDKs do OpenTelemetry com uma configuração de amostragem *always\$1on* para registrar de forma confiável 100% de extensões e obter visibilidade total das aplicações críticas com o CloudWatch Application Signals. Para obter mais informações, consulte um exemplo de [configuração do sampler do SDK Java do OpenTelemetry](https://opentelemetry.io/docs/languages/java/sdk/#sampler). Para obter um exemplo sobre como configurar o OpenTelemetry Collector com o endpoint do OTLP do X-Ray, consulte o repositório de [demonstração de sinais de aplicações](https://github.com/aws-observability/application-signals-demo/blob/main/scripts/opentelemetry/otel_simple_setup/opentelemetry.yaml).
Copie e cole o conteúdo abaixo para configurar o coletor com o objetivo de enviar métricas para endpoints do OTLP.
```
receivers:
otlp:
protocols:
http:
endpoint: "0.0.0.0:4318"
processors:
batch:
send_batch_size: 200
timeout: 10s
exporters:
otlphttp:
tls:
insecure: false
endpoint: metrics_otlp_endpoint
auth:
authenticator: sigv4auth
extensions:
sigv4auth:
service: "monitoring"
region: "region"
service:
extensions: [sigv4auth]
pipelines:
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp]
```
Confira a seguir um exemplo de como enviar métricas usando sigv4 para us-east-1.
```
receivers:
otlp:
protocols:
http:
endpoint: "0.0.0.0:4318"
processors:
batch:
send_batch_size: 200
timeout: 10s
exporters:
otlphttp:
tls:
insecure: false
endpoint: "https://monitoring.us-east-1.amazonaws.com/v1/metrics:443"
auth:
authenticator: sigv4auth
extensions:
sigv4auth:
service: "monitoring"
region: "us-east-1"
service:
extensions: [sigv4auth]
pipelines:
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp]
```
# Criar seu próprio OpenTelemetry Collector
Você pode criar seu próprio OpenTelemetry Collector personalizado para obter a melhor experiência de observabilidade de aplicações no CloudWatch com o OpenTelemetry. Nessa configuração, você precisa criar seu próprio OpenTelemetry Collector com componentes de código aberto do CloudWatch.
## Pré-requisito
Certifique-se de que *Transaction Search* esteja habilitado no CloudWatch. Para obter mais informações, consulte [Transaction Search](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/CloudWatch-Transaction-Search.html).
## Criar seu próprio coletor
Você pode criar seu próprio coletor com a configuração a seguir para monitorar a aplicação no CloudWatch com o OpenTelemetry. Para obter mais informações, consulte [Building a custom collector](https://opentelemetry.io/docs/collector/custom-collector/).
A configuração comum do CloudWatch.
```
dist:
name: otelcol-dev
description: OTel Collector for sending telemetry to CloudWatch.
output_path: ./otelcol-dev
extensions:
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/extension/sigv4authextension v0.111.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/extension/awsproxy v0.113.0
exporters:
- gomod: go.opentelemetry.io/collector/exporter/otlpexporter v0.111.0
- gomod: go.opentelemetry.io/collector/exporter/otlphttpexporter v0.111.0
receivers:
- gomod: go.opentelemetry.io/collector/receiver/otlpreceiver v0.111.0
```
Configuração adicional para rastreamentos.
```
# Enable Tracing
dist:
name: otelcol-dev
description: OTel Collector for sending telemetry to CloudWatch.
output_path: ./otelcol-dev
extensions:
#Include common configurations and your custom extensions
exporters:
#Include common configurations and your custom extensions
receivers:
- gomod: go.opentelemetry.io/collector/receiver/otlpreceiver v0.111.0
processors:
- gomod: github.com/amazon-contributing/opentelemetry-collector-contrib/processor/awsapplicationsignalsprocessor v0.113.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/processor/resourcedetectionprocessor v0.113.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/processor/metricstransformprocessor v0.113.0
replaces:
- github.com/open-telemetry/opentelemetry-collector-contrib/internal/aws/awsutil v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/internal/aws/awsutil v0.113.0
- github.com/open-telemetry/opentelemetry-collector-contrib/internal/aws/cwlogs v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/internal/aws/cwlogs v0.113.0
- github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsemfexporter v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/exporter/awsemfexporter v0.113.0
- github.com/openshift/api v3.9.0+incompatible => github.com/openshift/api v0.0.0-20180801171038-322a19404e37
```
**nota**
Observe o seguinte:
Depois que o coletor for criado, implante e configure o coletor personalizado em um ambiente de host ou do Kubernetes seguindo o procedimento em [Coletor do OpenTelemetry](CloudWatch-OTLPSimplesetup.md).
Para obter informações sobre como configurar o OpenTelemetry Collector personalizado com o Application Signals Processor, consulte um exemplo de [configuração personalizada do Application Signals](https://github.com/aws-observability/application-signals-demo/blob/main/scripts/opentelemetry/appsignals_custom_otel_setup/custom-opentelemetry.yaml). O Application Signals Processor é compatível apenas com as versões mais recentes dos OpenTelemetry Collectors para compilações personalizadas. Para obter informações sobre as versões compatíveis, consulte o [repositório opentelemetry-collector-contrib.](https://github.com/amazon-contributing/opentelemetry-collector-contrib/tags)
# Exportação de telemetria sem coletor usando o AWS Distro para OpenTelemetry (ADOT)
Você pode usar os SDKs do ADOT para operar sem coletor e enviar as métricas, os rastreamentos e os logs diretamente para endpoints do OTLP.
**nota**
O Application Signals inclui recursos de pesquisa de transações. Para evitar custos duplicados, desabilite o Application Signals no SDK do ADOT e mantenha `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` definido como false (configuração padrão).
**Topics**
+ [Pré-requisito](#CloudWatch-OTLP-UsingADOT-Prerequisite)
+ [Configurar as permissões do IAM para seu perfil](#setup-iam-permissions-role)
+ [Configurar os provedores de credenciais](#configure-credentials-providers)
+ [Habilitação dos SDKs do ADOT](#Enabling-ADOT)
## Pré-requisito
Se estiver usando rastreamentos, certifique-se de que a Pesquisa de transações esteja habilitada para enviar extensões para o endpoint do OTLP do X-Ray. Para obter mais informações, consulte [Conceitos básicos da Pesquisa de transações](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Transaction-Search-getting-started.html).
## Configurar as permissões do IAM para seu perfil
Siga as etapas abaixo para anexar as políticas do IAM necessárias para o seu perfil:
**Rastreamentos:**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e localize e selecione seu perfil configurado.
1. Na guia **Permissões**, escolha **Adicionar permissões** e, em seguida, **Anexar políticas**.
1. Usando a caixa de pesquisa, procure a política `AWSXrayWriteOnlyPolicy`.
1. Selecione a política `AWSXrayWriteOnlyPolicy` e escolha **Adicionar permissões**.
**Logs:**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e localize e selecione seu perfil configurado.
1. Na guia **Permissões**, escolha **Adicionar permissões** e depois **Criar política em linha**.
1. Selecione **CloudWatch Logs** para o serviço e, em **Ações permitidas**, filtre e selecione:
```
logs:PutLogEvents
logs:DescribeLogGroups
logs:DescribeLogStreams
```
1. Confira abaixo um exemplo de política do IAM que concede as permissões necessárias:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": [
"arn:aws:logs:*:*:log-group:*"
]
}
]
}
```
------
## Configurar os provedores de credenciais
O ADOT usa os SDKs da AWS para descobrir automaticamente as credenciais válidas necessárias para exportar seus dados de telemetria para a AWS. Para obter orientação sobre como configurar credenciais para seu ambiente específico, [consulte a documentação sobre como os SDKs da AWS](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) recuperam as credenciais.
**Configuração de credenciais do IAM para hosts on-premises:**
Configure suas credenciais da AWS no host on-premises ao inserir o comando a seguir. Substitua **ACCESS\$1KEY\$1ID** e **SECRET\$1ACCESS\$1KEY** pelas credenciais do seu usuário ou perfil do IAM configurado.
```
$ aws configure
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json
```
## Habilitação dos SDKs do ADOT
É possível habilitar o envio de logs e rastreamentos da sua aplicação diretamente para endpoints do OTLP por meio do SDK do AWS Distro para OpenTelemetry (ADOT) em Java, Node.js, Python e .NET.
------
#### [ Java ]
**nota**
Você deve usar o **ADOT Java Agent versão 2.11.2 ou posterior** para que esses recursos estejam disponíveis.
1. Faça download da versão mais recente do agente de instrumentação automática em Java do AWS Distro para OpenTelemetry. Você pode baixar a versão mais recente ao usar este comando:
```
curl -L -O https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/aws-opentelemetry-agent.jar
```
É possível visualizar informações sobre todas as versões liberadas em [aws-otel-java-instrumentation Releases](https://github.com/aws-observability/aws-otel-java-instrumentation/releases).
1. Para habilitar o exportador diferente que envia telemetria diretamente para endpoints do OTLP e otimizar os benefícios, use as seguintes variáveis de ambiente antes de iniciar a aplicação:
**Rastreamentos:**
+ Defina `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar o endpoint de rastreamentos do OTLP do X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Defina `OTEL_TRACES_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a variável `OTEL_RESOURCE_ATTRIBUTES` para especificar as informações a seguir como pares de chave/valor. Essas variáveis de ambiente são usadas pelo Application Signals, e são convertidas em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
+ (Opcional) `service.name` define o nome do serviço. Isso será exibido como o nome do serviço para a aplicação nos painéis do Application Signals. Se você não fornecer um valor para essa chave, o padrão `UnknownService` será usado.
+ (Opcional) `deployment.environment` define o ambiente em que a aplicação é executada. Isso será exibido como o ambiente **Hospedado em** da aplicação.
+ (Opcional) Para habilitar a correlação de logs, em `OTEL_RESOURCE_ATTRIBUTES`, defina uma variável de ambiente `aws.log.group.names` adicional para os grupos de logs da sua aplicação. Ao fazer isso, será possível correlacionar os rastreamentos e métricas da sua aplicação com as entradas de log relevantes desses grupos de logs. Para essa variável, substitua `$YOUR_APPLICATION_LOG_GROUP` pelos nomes do grupo de logs da sua aplicação. Se você tiver vários grupos de logs, é possível usar um e comercial (`&`) para separá-los, como neste exemplo: `aws.log.group.names=log-group-1&log-group-2`. Para permitir que a métrica registre a correlação em log, basta definir essa variável ambiental atual. Para obter mais informações, consulte [Habilitar a correlação entre métrica e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). Para habilitar a correlação entre logs e rastreamento, você também precisará alterar a configuração de registro em log em sua aplicação. Para obter mais informações, consulte [Habilitar a correlação entre rastreamento e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Logs:**
+ Defina `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar o endpoint de logs do OTLP do CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Defina `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar o grupo de logs e o fluxo de logs (observação: eles devem ser criados **antes** da execução do ADOT) para os quais você deseja exportar seus logs: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Defina `OTEL_LOGS_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
1. Defina `JAVA_TOOL_OPTIONS` para especificar o caminho em que o agente de instrumentação automática em Java do AWS Distro para OpenTelemetry está armazenado. Por exemplo:
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH="./aws-opentelemetry-agent.jar"
```
1. Agora, sua aplicação deve estar sendo executada com a instrumentação Java do ADOT e vai gerar logs e spans. As extensões serão armazenadas no grupo de logs `aws/spans` do CloudWatch, enquanto os logs serão armazenados no grupo de logs especificado no cabeçalho `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. Você também pode visualizar os logs e as métricas correlacionados com suas extensões no console de rastreamentos e métricas do CloudWatch.
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior. Veja a seguir um exemplo de um script inicial.
```
JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
java -jar $MY_JAVA_APP.jar
```
------
#### [ Node.js ]
**nota**
Você deve usar o **ADOT JavaScript versão 0.7.0 ou posterior** para que esses recursos estejam disponíveis.
1. Faça download da versão mais recente da instrumentação automática em JavaScript do AWS Distro para OpenTelemetry. Instale-o executando o seguinte comando da .
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
É possível visualizar informações sobre todas as versões liberadas em [aws-otel-js-instrumentation Releases](https://github.com/aws-observability/aws-otel-js-instrumentation/releases).
1. Para habilitar o exportador diferente que envia telemetria diretamente para endpoints do OTLP e otimizar os benefícios, use as seguintes variáveis de ambiente antes de iniciar a aplicação:
**Rastreamentos:**
+ Defina `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar o endpoint de rastreamentos do OTLP do X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Defina `OTEL_TRACES_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a variável `OTEL_RESOURCE_ATTRIBUTES` para especificar as informações a seguir como pares de chave/valor. Essas variáveis de ambiente são usadas pelo Application Signals, e são convertidas em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
+ (Opcional) `service.name` define o nome do serviço. Isso será exibido como o nome do serviço para a aplicação nos painéis do Application Signals. Se você não fornecer um valor para essa chave, o padrão `UnknownService` será usado.
+ (Opcional) `deployment.environment` define o ambiente em que a aplicação é executada. Essa variável será exibida como o ambiente **Hospedado em** da aplicação.
+ (Opcional) Para habilitar a correlação de logs, em `OTEL_RESOURCE_ATTRIBUTES`, defina uma variável de ambiente `aws.log.group.names` adicional para os grupos de logs da sua aplicação. Ao fazer isso, será possível correlacionar os rastreamentos e métricas da sua aplicação com as entradas de log relevantes desses grupos de logs. Para essa variável, substitua `$YOUR_APPLICATION_LOG_GROUP` pelos nomes do grupo de logs da sua aplicação. Se você tiver vários grupos de logs, é possível usar um e comercial (`&`) para separá-los, como neste exemplo: `aws.log.group.names=log-group-1&log-group-2`. Para permitir que a métrica registre a correlação em log, basta definir essa variável ambiental atual. Para obter mais informações, consulte [Habilitar a correlação entre métrica e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). Para habilitar a correlação entre logs e rastreamento, você também precisará alterar a configuração de registro em log em sua aplicação. Para obter mais informações, consulte [Habilitar a correlação entre rastreamento e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Logs:**
+ Defina `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar o endpoint de logs do OTLP do CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Defina `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar o grupo de logs e o fluxo de logs (observação: eles devem ser criados **antes** da execução do ADOT) para os quais você deseja exportar seus logs: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Defina `OTEL_LOGS_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
1. Agora, sua aplicação deve estar sendo executada com a instrumentação JavaScript do ADOT e vai gerar logs e spans. As extensões serão armazenadas no grupo de logs `aws/spans` do CloudWatch, enquanto os logs serão armazenados no grupo de logs especificado no cabeçalho `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. Você também pode visualizar os logs e as métricas correlacionados com suas extensões no console de rastreamentos e métricas do CloudWatch.
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior. Veja a seguir um exemplo de um script inicial.
Substitua `$SVC_NAME` pelo nome da aplicação. Isso será exibido como o nome da aplicação.
```
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' your-application.js
```
------
#### [ Python ]
**nota**
Você deve usar o **ADOT Python versão 0.10.0 ou posterior** e ter **`botocore`** instalado para que esses recursos estejam disponíveis.
1. Faça download da versão mais recente da instrumentação automática em Python do AWS Distro para OpenTelemetry. Instale-o executando o seguinte comando da .
```
pip install aws-opentelemetry-distro
```
É possível visualizar as informações sobre todas as versões liberadas em [aws-otel-python-instrumentation Releases](https://github.com/aws-observability/aws-otel-python-instrumentation/releases).
1. Para habilitar o exportador diferente que envia telemetria diretamente para endpoints do OTLP e otimizar os benefícios, use as seguintes variáveis de ambiente antes de iniciar a aplicação:
**Para configurações de rastreamentos e logs, você deve definir as seguintes variáveis de ambiente:**
+ `OTEL_PYTHON_DISTRO` para `aws_distro`
+ `OTEL_PYTHON_CONFIGURATOR` para `aws_configurator`
**Rastreamentos:**
+ Defina `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar o endpoint de rastreamentos do OTLP do X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Defina `OTEL_TRACES_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a variável `OTEL_RESOURCE_ATTRIBUTES` para especificar as informações a seguir como pares de chave/valor. Essas variáveis de ambiente são usadas pelo Application Signals, e são convertidas em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
+ (Opcional) `service.name` define o nome do serviço. Isso será exibido como o nome do serviço para a aplicação nos painéis do Application Signals. Se você não fornecer um valor para essa chave, o padrão `UnknownService` será usado.
+ (Opcional) `deployment.environment` define o ambiente em que a aplicação é executada. Essa variável será exibida como o ambiente **Hospedado em** da aplicação.
+ (Opcional) Para habilitar a correlação de logs, em `OTEL_RESOURCE_ATTRIBUTES`, defina uma variável de ambiente `aws.log.group.names` adicional para os grupos de logs da sua aplicação. Ao fazer isso, será possível correlacionar os rastreamentos e métricas da sua aplicação com as entradas de log relevantes desses grupos de logs. Para essa variável, substitua `$YOUR_APPLICATION_LOG_GROUP` pelos nomes do grupo de logs da sua aplicação. Se você tiver vários grupos de logs, é possível usar um e comercial (`&`) para separá-los, como neste exemplo: `aws.log.group.names=log-group-1&log-group-2`. Para permitir que a métrica registre a correlação em log, basta definir essa variável ambiental atual. Para obter mais informações, consulte [Habilitar a correlação entre métrica e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). Para habilitar a correlação entre logs e rastreamento, você também precisará alterar a configuração de registro em log em sua aplicação. Para obter mais informações, consulte [Habilitar a correlação entre rastreamento e logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Logs:**
+ Defina `OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED` como `true`
+ Defina `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar o endpoint de logs do OTLP do CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Defina `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar o grupo de logs e o fluxo de logs (observação: eles devem ser criados **antes** da execução do ADOT) para os quais você deseja exportar seus logs: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por exemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Defina `OTEL_LOGS_EXPORTER` como `otlp` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
+ Defina a varável `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` como `http/protobuf` (é opcional e será o valor padrão se essa variável de ambiente não estiver definida).
1. Agora, sua aplicação deve estar sendo executada com a instrumentação Python do ADOT e vai gerar logs e spans. As extensões serão armazenadas no grupo de logs `aws/spans` do CloudWatch, enquanto os logs serão armazenados no grupo de logs especificado no cabeçalho `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. Você também pode visualizar os logs e as métricas correlacionados com suas extensões no console de rastreamentos e métricas do CloudWatch.
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior. Veja a seguir um exemplo de um script inicial.
Substitua `$SVC_NAME` pelo nome da aplicação. Isso será exibido como o nome da aplicação.
Substitua `$PYTHON_APP` pelo local e pelo nome da aplicação.
```
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
opentelemetry-instrument python $MY_PYTHON_APP.py
```
------
#### [ .Net ]
**nota**
É necessário ter o **ADOT .NET versão 1.8.0 ou posterior** para que esses recursos estejam disponíveis.
Atualmente, a compactação não é compatível.
Atualmente, os logs não são compatíveis.
Faça download da versão mais recente do agente de instrumentação automática para .NET do AWS Distro para OpenTelemetry. É possível visualizar as informações sobre todas as versões liberadas em [aws-otel-dotnet-instrumentation Releases](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases).
Para habilitar os diferentes exportadores que enviam telemetria diretamente para endpoints do OTLP e otimizar os benefícios, use as seguintes variáveis de ambiente antes de iniciar sua aplicação (substitua `dotnet-service-name` na variável `OTEL_RESOURCE_ATTRIBUTES` do ambiente pelo nome do serviço de sua escolha):
**Rastreamentos:**
+ Você **DEVE** definir `OTEL_TRACES_EXPORTER` como `none`
+ Você **DEVE** definir `OTEL_AWS_SIG_V4_ENABLED` como `true`
Esse recurso **não é habilitado automaticamente no. NET**. A variável de ambiente é necessária especificamente para identificar esse caso de uso na instrumentação do .NET. Esse requisito é exclusivo do .NET e **não se aplica a outras linguagens compatíveis**.
Confira abaixo um exemplo de configuração para Linux.
```
export INSTALL_DIR=OpenTelemetryDistribution
export CORECLR_ENABLE_PROFILING=1
export CORECLR_PROFILER={918728DD-259F-4A6A-AC2B-B85E1B658318}
export CORECLR_PROFILER_PATH=${INSTALL_DIR}/linux-x64/OpenTelemetry.AutoInstrumentation.Native.so
export DOTNET_ADDITIONAL_DEPS=${INSTALL_DIR}/AdditionalDeps
export DOTNET_SHARED_STORE=${INSTALL_DIR}/store
export DOTNET_STARTUP_HOOKS=${INSTALL_DIR}/net/OpenTelemetry.AutoInstrumentation.StartupHook.dll
export OTEL_DOTNET_AUTO_HOME=${INSTALL_DIR}
export OTEL_DOTNET_AUTO_PLUGINS="AWS.Distro.OpenTelemetry.AutoInstrumentation.Plugin, AWS.Distro.OpenTelemetry.AutoInstrumentation"
export OTEL_TRACES_EXPORTER=none
export OTEL_AWS_SIG_V4_ENABLED=true
export OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
export OTEL_METRICS_EXPORTER=none
export OTEL_LOGS_EXPORTER=none
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces
```
Confira abaixo um exemplo de configuração para Windows Server:
```
$env:INSTALL_DIR = "OpenTelemetryDistribution"
$env:CORECLR_ENABLE_PROFILING = 1
$env:CORECLR_PROFILER = "{918728DD-259F-4A6A-AC2B-B85E1B658318}"
$env:CORECLR_PROFILER_PATH = Join-Path $env:INSTALL_DIR "win-x64/OpenTelemetry.AutoInstrumentation.Native.dll"
$env:DOTNET_ADDITIONAL_DEPS = Join-Path $env:INSTALL_DIR "AdditionalDeps"
$env:DOTNET_SHARED_STORE = Join-Path $env:INSTALL_DIR "store"
$env:DOTNET_STARTUP_HOOKS = Join-Path $env:INSTALL_DIR "net/OpenTelemetry.AutoInstrumentation.StartupHook.dll"
$env:OTEL_DOTNET_AUTO_HOME = $env:INSTALL_DIR
$env:OTEL_DOTNET_AUTO_PLUGINS = "AWS.Distro.OpenTelemetry.AutoInstrumentation.Plugin, AWS.Distro.OpenTelemetry.AutoInstrumentation"
$env:OTEL_TRACES_EXPORTER=none
$env:OTEL_AWS_SIG_V4_ENABLED=true
$env:OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
$env:OTEL_METRICS_EXPORTER=none
$env:OTEL_LOGS_EXPORTER=none
$env:OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
$env:OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces
```
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior.
1. (Opcional) Como alternativa, você pode usar os scripts de instalação fornecidos para ajudar na instalação e configuração do pacote de instrumentação automática do AWS Distro for OpenTelemetry .NET.
Para Linux, baixe e instale o script de instalação do Bash na página de versões do GitHub:
```
# Download and Install
curl -L -O https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/aws-otel-dotnet-install.sh
chmod +x ./aws-otel-dotnet-install.sh
./aws-otel-dotnet-install.sh
# Instrument
. $HOME/.otel-dotnet-auto/instrument.shexport OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
```
Para Windows Server, baixe e instale o script de instalação do PowerShell na página de versões do GitHub:
```
# Download and Install
$module_url = "https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/AWS.Otel.DotNet.Auto.psm1"
$download_path = Join-Path $env:temp "AWS.Otel.DotNet.Auto.psm1"
Invoke-WebRequest -Uri $module_url -OutFile $download_path
Import-Module $download_path
Install-OpenTelemetryCore
# Instrument
Import-Module $download_path
Register-OpenTelemetryForCurrentSession -OTelServiceName "dotnet-service-name"
Register-OpenTelemetryForIIS
```
Você pode encontrar o pacote NuGet do pacote de instrumentação automática do AWS Distro for OpenTelemetry .NET no [repositório oficial do NuGet](https://www.nuget.org/packages/AWS.Distro.OpenTelemetry.AutoInstrumentation). Certifique-se de verificar o [arquivo README](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/blob/main/src/AWS.Distro.OpenTelemetry.AutoInstrumentation/nuget-readme.md) para obter instruções.
------
# Habilitação de métricas fornecidas no PromQL
Você pode habilitar o enriquecimento dos dados do OTel para que as métricas fornecidas dos [recursos compatíveis da AWS](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/UsingResourceTagsForTelemetry.html) sejam consultáveis por meio do PromQL. Depois de habilitadas, as métricas que contêm uma dimensão de identificador de recurso (por exemplo, CPUUtilization do EC2 com uma dimensão InstanceID) são enriquecidas com o ARN do recurso e os rótulos de tags do recurso e se tornam consultáveis usando o PromQL.
A métrica enriquecida preserva o nome da métrica original e as dimensões do CloudWatch e adiciona:
+ **Atributos do recurso**: o ARN do recurso (`cloud.resource_id`), o provedor de nuvem, a região e o ID da conta.
+ **Escopo da instrumentação**: identifica o serviço de origem e marca a métrica como enriquecida pelo OTel.
+ **Tags de recursos** : quaisquer tags de recursos da AWS associadas ao recurso, consultáveis como rótulos do PromQL.
A métrica clássica original do CloudWatch não foi modificada e permanece disponível por meio das APIs existentes do CloudWatch.
## Habilitação do enriquecimento do OpenTelemetry para métricas fornecidas
Antes de iniciar o enriquecimento do OTel, você deve [habilitar as tags de recursos na telemetria](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/EnableResourceTagsOnTelemetry.html) da sua conta.
Você pode habilitar o enriquecimento do OTel para sua conta em uma região específica usando o console do CloudWatch, a AWS CLI ou o AWS SDK.
Você precisará de permissões para a seguinte operação: `cloudwatch:StartOTelEnrichment`
**Para habilitar o enriquecimento do OTel para métricas da AWS (console do CloudWatch)**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **CloudWatch** e depois **Configurações**.
1. No painel **Habilitar o enriquecimento do OTel para métricas da AWS**, ative o recurso.
**AWS CLI**
```
aws cloudwatch start-o-tel-enrichment
```
Para habilitar em várias regiões, invoque a API em cada região de interesse.
Depois que o enriquecimento estiver habilitado, você poderá começar a consultar as métricas fornecidas por meio do PromQL. Consulte : [Consulta a métricas fornecidas pela AWS com o PromQL](CloudWatch-PromQL-Querying.md#CloudWatch-PromQL-Querying-Vended).