# Habilitar aplicações no Amazon EC2
Habilite o CloudWatch Application Signals no Amazon EC2 usando as etapas de configuração personalizadas descritas nesta seção.
Para aplicações em execução no Amazon EC2, instale e configure por sua conta o agente do CloudWatch e o AWS Distro para OpenTelemetry. Nessas arquiteturas habilitadas com uma configuração personalizada do Application Signals, o Application Signals não descobre automaticamente os nomes dos seus serviços ou dos hosts ou clusters em que eles são executados. Você deve especificar esses nomes durante a configuração personalizada, e os nomes especificados serão exibidos nos painéis do Application Signals.
As instruções nesta seção são destinadas a aplicações em Java, Python e .NET. As etapas apresentadas foram testadas em instâncias do Amazon EC2, mas também devem funcionar em outras arquiteturas compatíveis com o AWS Distro para OpenTelemetry.
**Requisitos**
+ Para obter suporte para o Application Signals, é necessário usar a versão mais recente do agente do CloudWatch e do agente do AWS Distro para OpenTelemetry.
+ Você deve ter a AWS CLI instalada na instância. Recomendamos a versão 2 da AWS CLI, mas a versão 1 também deve funcionar. Para obter mais informações sobre como instalar a AWS CLI, consulte [Instalar ou atualizar para a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Importante**
Se você já estiver usando o OpenTelemetry com uma aplicação para a qual pretende habilitar o Application Signals, consulte [Sistemas compatíveis](CloudWatch-Application-Signals-supportmatrix.md) antes de habilitar o Application Signals.
## Etapa 1: habilitar o Application Signals em sua conta
Você deve primeiro habilitar o Application Signals na conta. Se você não tiver feito isso, consulte [Habilitar o Application Signals na conta](CloudWatch-Application-Signals-Enable.md).
## Etapa 2: fazer download e iniciar o agente do CloudWatch
**Para instalar o agente do CloudWatch como parte da habilitação do Application Signals em uma instância do Amazon EC2 ou em um host on-premises**
1. Faça download da versão mais recente do agente do CloudWatch para a instância. Se a instância já tiver o agente do CloudWatch instalado, talvez seja necessário atualizá-lo. Somente as versões do agente liberadas em 30 de novembro de 2023, ou após essa data, oferecem suporte ao CloudWatch Application Signals.
1. Antes de iniciar o agente do CloudWatch, configure-o para habilitar o Application Signals. O exemplo apresentado a seguir corresponde a uma configuração do agente do CloudWatch que habilita o Application Signals para as métricas e os rastreamentos em um host do EC2.
Recomendamos que você coloque esse arquivo em `/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json` nos sistemas Linux.
```
{
"traces": {
"traces_collected": {
"application_signals": {}
}
},
"logs": {
"metrics_collected": {
"application_signals": {}
}
}
}
```
1. Anexe a política do IAM **CloudWatchAgentServerPolicy** ao perfil do IAM da sua instância do Amazon EC2. Para obter permissões para hosts on-premises, consulte [Permissões para servidores on-premises](#Enable-OnPremise-Permissions).
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e localize o perfil usado pela sua instância do Amazon EC2. Em seguida, escolha o nome desse perfil.
1. Na guia **Permissões**, escolha **Adicionar permissões** e, em seguida, **Anexar políticas**.
1. Localize **CloudWatchAgentServerPolicy**. Use a caixa de pesquisa, se necessário. Em seguida, marque a caixa de seleção dessa política e escolha **Adicionar permissões**.
1. Inicie o agente do CloudWatch ao inserir os comandos apresentados a seguir. Substitua {{agent-config-file-path}} pelo caminho para o arquivo de configuração do agente do CloudWatch, como `./amazon-cloudwatch-agent.json`. Você deve incluir o prefixo `file:`, conforme mostrado.
```
export CONFIG_FILE_PATH=./amazon-cloudwatch-agent.json
```
```
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
-a fetch-config \
-m ec2 -s -c file:{{agent-config-file-path}}
```
### Permissões para servidores on-premises
Para um host on-premises, você precisará fornecer à AWS uma autorização ao seu dispositivo.
**Para configurar permissões para um host on-premises**
1. Crie o usuário do IAM a ser usado para fornecer permissões ao seu host 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. Em seguida, 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. Escolha **Próximo**.
1. Na página **Revisar e criar**, verifique se você está satisfeito com o nome de usuário e se a política **CloudWatchAgentServerPolicy** está no **Resumo de permissões**.
1. Escolha **Criar usuário**
1. Crie e recupere sua chave de acesso da AWS e uma chave secreta:
1. 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**. Depois, 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\_KEY\_ID}} e {{SECRET\_ACCESS\_ID}} 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
```
## Etapa 3: instrumentalizar a aplicação e iniciá-la
A próxima etapa corresponde à instrumentação da sua aplicação para o CloudWatch Application Signals.
------
#### [ Java ]
**Para instrumentalizar as aplicações em Java como parte da habilitação do Application Signals em uma instância do Amazon EC2 ou um host on-premises**
1. Faça download da versão mais recente do agente de instrumentação automática em Java do AWS Distro para OpenTelemetry. É possível fazer download da versão mais recente ao usar [este link](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 otimizar os benefícios do Application Signals, use as variáveis de ambiente para fornecer informações adicionais antes de iniciar a aplicação. Essas informações serão exibidas nos painéis do Application Signals.
1. Para a variável `OTEL_RESOURCE_ATTRIBUTES`, especifique as seguintes informações como pares de chave/valor:
+ (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 nos painéis do Application Signals. Caso você não especifique, um dos seguintes padrões será usado:
+ Se for uma instância que faz parte de um grupo do Auto Scaling, ela será definida como `ec2:{{name-of-Auto-Scaling-group}}`.
+ Se for uma instância do Amazon EC2 que não faz parte de um grupo do Auto Scaling, ela será definida como `ec2:default`.
+ Se for um host on-premises, ele será definido como `generic:default`.
Essa variável de ambiente é usada somente pelo Application Signals, e é convertida em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
+ Para a variável `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique o URL do endpoint de base para o qual os rastreamentos serão exportados. O agente do CloudWatch mostra 4316 como a porta OLTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
+ Para a variável `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique o URL do endpoint de base para o qual as métricas serão exportadas. O agente do CloudWatch mostra 4316 como a porta OLTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
+ Para a variável `JAVA_TOOL_OPTIONS`, especifique o caminho no qual o agente de instrumentação automática em Java do AWS Distro para OpenTelemetry está armazenado.
```
export JAVA_TOOL_OPTIONS=" -javaagent:{{$AWS_ADOT_JAVA_INSTRUMENTATION_PATH}}"
```
Por exemplo:
```
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH=./aws-opentelemetry-agent.jar
```
+ Para a variável `OTEL_METRICS_EXPORTER`, recomendamos definir o valor como `none`. Isso desabilita outros exportadores de métricas para que somente o exportador do Application Signals seja usado.
+ Defina `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` como `true`. Isso gera métricas do Application Signals usando os rastreamentos.
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior. Veja a seguir um exemplo de um script inicial.
**nota**
A configuração a seguir é compatível somente com as versões 1.32.2 e posteriores do agente de instrumentação automática do AWS Distro para OpenTelemetry para Java.
```
JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name={{$YOUR_SVC_NAME}}" \
java -jar $MY_JAVA_APP.jar
```
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
Veja a seguir um exemplo de um script inicial que ajuda a habilitar a correlação de logs.
```
JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORT=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names={{$YOUR_APPLICATION_LOG_GROUP}},service.name={{$YOUR_SVC_NAME}}" \
java -jar $MY_JAVA_APP.jar
```
------
#### [ Python ]
**nota**
Se você estiver usando um servidor WSGI para a aplicação em Python, além das etapas apresentadas a seguir nesta seção, consulte [Não há dados do Application Signals para aplicações em Python que usam um servidor WSGI](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-Python-WSGI) para obter informações sobre como fazer o Application Signals funcionar.
**Como instrumentalizar as aplicações em Python como parte da habilitação do Application Signals em uma instância do Amazon EC2**
1. Faça download da versão mais recente do agente de instrumentação automática do AWS Distro para OpenTelemetry em Python. Instale-o executando o seguinte comando da .
```
pip install aws-opentelemetry-distro
```
É possível visualizar informações sobre todas as versões lançadas em [AWS Distro for OpenTelemetry Python instrumentation](https://github.com/aws-observability/aws-otel-python-instrumentation/releases).
1. Para otimizar os benefícios do Application Signals, use as variáveis de ambiente para fornecer informações adicionais antes de iniciar a aplicação. Essas informações serão exibidas nos painéis do Application Signals.
1. Para a variável `OTEL_RESOURCE_ATTRIBUTES`, especifique as seguintes informações como pares de chave/valor:
+ `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.
+ `deployment.environment` define o ambiente em que a aplicação é executada. Essa variável será exibida como o ambiente **Hospedado em** da aplicação nos painéis do Application Signals. Caso você não especifique, um dos seguintes padrões será usado:
+ Se for uma instância que faz parte de um grupo do Auto Scaling, ela será definida como `ec2:{{name-of-Auto-Scaling-group}}`.
+ Se for uma instância do Amazon EC2 que não faz parte de um grupo do Auto Scaling, ela será definida como `ec2:default`.
+ Se for um host on-premises, ele será definido como `generic:default`.
Essa chave de atributo é usada somente pelo Application Signals e é convertida em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
1. Para a variável `OTEL_EXPORTER_OTLP_PROTOCOL`, especifique `http/protobuf` para exportar dados de telemetria por HTTP para os endpoints do agente do CloudWatch listados nas etapas a seguir.
1. Para a variável `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique o URL do endpoint de base para o qual os rastreamentos serão exportados. O agente do CloudWatch mostra 4316 como a porta OLTP via HTTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. Para a variável `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique o URL do endpoint de base para o qual as métricas serão exportadas. O agente do CloudWatch mostra 4316 como a porta OLTP via HTTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. Para a variável `OTEL_METRICS_EXPORTER`, recomendamos definir o valor como `none`. Isso desabilita outros exportadores de métricas para que somente o exportador do Application Signals seja usado.
1. Defina a variável `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` como `true` para que seu contêiner comece a enviar rastreamentos de X-Ray e métricas do CloudWatch para o Application Signals.
1. Inicie a aplicação com as variáveis de ambiente discutidas na etapa anterior. Veja a seguir um exemplo de um script inicial.
+ Substitua `$SVC_NAME` pelo nome da aplicação. Essa variável será exibida como o nome da aplicação nos painéis do Application Signals.
+ Substitua `$PYTHON_APP` pelo local e pelo nome da aplicação.
```
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_PYTHON_DISTRO=aws_distro \
OTEL_PYTHON_CONFIGURATOR=aws_configurator \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name={{$SVC_NAME}}" \
opentelemetry-instrument python {{$MY_PYTHON_APP.py}}
```
Antes de habilitar o Application Signals para suas aplicações em Python, esteja ciente das considerações apresentadas a seguir.
+ Em algumas aplicações em contêineres, uma variável de ambiente `PYTHONPATH` ausente pode, às vezes, causar falhas na inicialização da aplicação. Para resolver isso, certifique-se de definir a variável de ambiente `PYTHONPATH` para o local do diretório de trabalho da sua aplicação. Isso ocorre devido a um problema conhecido com a instrumentação automática do OpenTelemetry. Para obter mais informações sobre esse problema, consulte [Python autoinstrumentation setting of PYTHONPATH is not compliant](https://github.com/open-telemetry/opentelemetry-operator/issues/2302).
+ Para aplicações em Django, existem configurações adicionais necessárias, descritas na [documentação do OpenTelemetry em Python](https://opentelemetry-python.readthedocs.io/en/latest/examples/django/README.html).
+ Use o sinalizador `--noreload` para evitar o recarregamento automático.
+ Defina a variável de ambiente `DJANGO_SETTINGS_MODULE` para o local do arquivo `settings.py` da sua aplicação em Django. Isso garante que o OpenTelemetry possa acessar e se integrar adequadamente às suas configurações do Django.
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
Veja a seguir um exemplo de um script inicial que ajuda a habilitar a correlação de logs.
```
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_PYTHON_DISTRO=aws_distro \
OTEL_PYTHON_CONFIGURATOR=aws_configurator \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names={{$YOUR_APPLICATION_LOG_GROUP}},service.name={{$YOUR_SVC_NAME}}" \
java -jar {{$MY_PYTHON_APP.jar}}
```
------
#### [ .NET ]
**Para instrumentalizar as aplicações em .NET como parte da habilitação do Application Signals em uma instância do Amazon EC2 ou um host on-premises**
1. Faça download da versão mais recente do agente de instrumentação automática para .NET do AWS Distro para OpenTelemetry. Você pode baixar a versão mais recente em [aws-otel-dotnet-instrumentation Releases](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases).
1. Para habilitar o Application Signals, defina as seguintes variáveis de ambiente para fornecer informações adicionais antes de iniciar a aplicação. Essas variáveis são necessárias para configurar o hook de inicialização da instrumentação .NET, antes de você iniciar sua aplicação .NET. Substitua `dotnet-service-name` na variável de ambiente `OTEL_RESOURCE_ATTRIBUTES` pelo nome do serviço de sua escolha.
+ O seguinte é um exemplo 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_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4316
export OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://127.0.0.1:4316/v1/metrics
export OTEL_METRICS_EXPORTER=none
export OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true
export OTEL_TRACES_SAMPLER=xray
export OTEL_TRACES_SAMPLER_ARG=http://127.0.0.1:2000
```
+ Veja a seguir um exemplo 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_RESOURCE_ATTRIBUTES = "service.name=dotnet-service-name"
$env:OTEL_EXPORTER_OTLP_PROTOCOL = "http/protobuf"
$env:OTEL_EXPORTER_OTLP_ENDPOINT = "http://127.0.0.1:4316"
$env:OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT = "http://127.0.0.1:4316/v1/metrics"
$env:OTEL_METRICS_EXPORTER = "none"
$env:OTEL_AWS_APPLICATION_SIGNALS_ENABLED = "true"
$env:OTEL_TRACES_SAMPLER = "xray"
$env:OTEL_TRACES_SAMPLER_ARG = "http://127.0.0.1:2000"
```
1. Inicie a aplicação com as variáveis de ambiente listadas na etapa anterior.
(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.sh
export 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.
------
#### [ Node.js ]
**nota**
Se você estiver habilitando o Application Signals para uma aplicação do Node.js com ESM, consulte [Setting up a Node.js application with the ESM module format](#EC2-NodeJs-ESM) antes de iniciar essas etapas.
**Como instrumentar as aplicações em Node.js como parte da habilitação do Application Signals em uma instância do Amazon EC2**
1. Faça o download da versão mais recente do agente de instrumentação automática em JavaScript do AWS Distro para OpenTelemetry para o Node.js. Instale-o executando o seguinte comando da .
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
É possível obter informações sobre todas as versões lançadas em [AWS Distro for OpenTelemetry JavaScript instrumentation](https://github.com/aws-observability/aws-otel-js-instrumentation/releases).
1. Para otimizar os benefícios do Application Signals, use as variáveis de ambiente para fornecer informações adicionais antes de iniciar a aplicação. Essas informações serão exibidas nos painéis do Application Signals.
1. Para a variável `OTEL_RESOURCE_ATTRIBUTES`, especifique as seguintes informações como pares de chave/valor:
+ `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.
+ `deployment.environment` define o ambiente em que a aplicação é executada. Essa variável será exibida como o ambiente **Hospedado em** da aplicação nos painéis do Application Signals. Caso você não especifique, um dos seguintes padrões será usado:
+ Se for uma instância que faz parte de um grupo do Auto Scaling, ela será definida como `ec2:{{name-of-Auto-Scaling-group}}`.
+ Se for uma instância do Amazon EC2 que não faz parte de um grupo do Auto Scaling, ela será definida como `ec2:default`.
+ Se for um host on-premises, ele será definido como `generic:default`.
Essa chave de atributo é usada somente pelo Application Signals e é convertida em anotações de rastreamentos do X-Ray e em dimensões de métricas do CloudWatch.
1. Para a variável `OTEL_EXPORTER_OTLP_PROTOCOL`, especifique `http/protobuf` para exportar dados de telemetria por HTTP para os endpoints do agente do CloudWatch listados nas etapas a seguir.
1. Para a variável `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique o URL do endpoint de base para o qual os rastreamentos serão exportados. O agente do CloudWatch mostra 4316 como a porta OLTP via HTTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. Para a variável `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique o URL do endpoint de base para o qual as métricas serão exportadas. O agente do CloudWatch mostra 4316 como a porta OLTP via HTTP. No Amazon EC2, como as aplicações se comunicam com o agente do CloudWatch local, é necessário definir esse valor como . `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. Para a variável `OTEL_METRICS_EXPORTER`, recomendamos definir o valor como `none`. Isso desabilita outros exportadores de métricas para que somente o exportador do Application Signals seja usado.
1. Defina a variável `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` como `true` para que seu contêiner comece a enviar rastreamentos de X-Ray e métricas do CloudWatch para o Application Signals.
1. Inicie a aplicação com as variáveis de ambiente discutidas na etapa anterior. Veja a seguir um exemplo de um script inicial.
+ Substitua `$SVC_NAME` pelo nome da aplicação. Essa variável será exibida como o nome da aplicação nos painéis do Application Signals.
```
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name={{$SVC_NAME}}" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' {{your-application.js}}
```
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
Veja a seguir um exemplo de um script inicial que ajuda a habilitar a correlação de logs.
```
export OTEL_METRICS_EXPORTER=none \
export OTEL_LOGS_EXPORTER=none \
export OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
export OTEL_TRACES_SAMPLER=xray \
export OTEL_TRACES_SAMPLER_ARG=endpoint=http://localhost:2000 \
export OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
export OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names={{$YOUR_APPLICATION_LOG_GROUP}},service.name={{$SVC_NAME}}" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' {{your-application.js}}
```
**Configuração de uma aplicação do Node.js usando o formato de módulo ESM**
Fornecemos suporte limitado para aplicações do Node.js com o formato de módulo ESM. Para obter detalhes, consulte [Limitações conhecidas sobre o uso de ESM com o Node.js](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations).
Para habilitar o Application Signals em uma aplicação do Node.js com o ESM, será necessário modificar as etapas no procedimento anterior.
Primeiro, instale `@opentelemetry/instrumentation` à aplicação do Node.js:
```
npm install @opentelemetry/instrumentation@0.54.0
```
Em seguida, nas etapas 3 e 4 do procedimento anterior, altere as opções do nó de:
```
--require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register'
```
Para o seguinte:
```
--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs
```
------
## Habilitar o Application Signals no Amazon EC2 usando o protocolo de contexto para modelos (MCP)
Você pode usar o servidor MCP (protocolo de contexto para modelos) do Application Signals do CloudWatch para habilitar o Application Signals nas instâncias do Amazon EC2 por meio de interações conversacionais de IA. Isso fornece uma interface de linguagem natural para configurar o monitoramento do Application Signals.
O servidor MCP automatiza o processo de habilitação compreendendo os requisitos e gerando a configuração apropriada. Em vez de seguir as etapas de configuração manualmente, você pode simplesmente descrever o que deseja habilitar.
### Pré-requisitos
Antes de usar o servidor MCP para habilitar o Application Signals, certifique-se de ter:
+ Um ambiente de desenvolvimento compatível com MCP (como Kiro, Claude Desktop, VSCode com extensões MCP ou outras ferramentas compatíveis com MCP)
+ O servidor MCP do Application Signals do CloudWatch configurado no IDE. Para obter instruções detalhadas de configuração, consulte a documentação do [servidor MCP do Application Signals do CloudWatch](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).
### Usar um servidor MCP
Depois de configurar o servidor MCP do CloudWatch Application Signals no IDE, você pode solicitar orientação sobre a habilitação usando prompts em linguagem natural. Embora o assistente de codificação possa inferir o contexto da estrutura do projeto, fornecer detalhes específicos nas instruções ajuda a garantir uma orientação mais precisa e relevante. Inclua informações como a linguagem da aplicação, detalhes da instância e caminhos absolutos para a infraestrutura e o código da aplicação.
**Prompts de acordo com as práticas recomendadas (específicos e completos):**
```
"Enable Application Signals for my Python service running on EC2.
My app code is in /home/ec2-user/flask-api and IaC is in /home/ec2-user/flask-api/terraform"
"I want to add observability to my Java application on EC2.
The application code is at /opt/apps/checkout-service and
the infrastructure code is at /opt/apps/checkout-service/cloudformation"
"Help me instrument my Node.js application on EC2 with Application Signals.
Application directory: /home/ubuntu/payment-api
Terraform code: /home/ubuntu/payment-api/terraform"
```
**Prompts menos eficazes:**
```
"Enable monitoring for my app"
→ Missing: platform, language, paths
"Enable Application Signals. My code is in ./src and IaC is in ./infrastructure"
→ Problem: Relative paths instead of absolute paths
"Enable Application Signals for my EC2 service at /home/user/myapp"
→ Missing: programming language
```
**Modelo rápido:**
```
"Enable Application Signals for my [LANGUAGE] service on EC2.
App code: [ABSOLUTE_PATH_TO_APP]
IaC code: [ABSOLUTE_PATH_TO_IAC]"
```
### Benefícios de usar o servidor MCP
O uso do servidor MCP do CloudWatch Application Signals oferece várias vantagens:
+ **Interface em linguagem natural:** descreva o que você deseja habilitar sem memorizar comandos nem sintaxe de configuração
+ **Orientação contextual:** o servidor MCP compreende seu ambiente específico e fornece recomendações personalizadas
+ **Menos erros:** a geração automatizada de configuração minimiza os erros da digitação manual
+ **Configuração mais rápida:** passe da intenção à implementação mais rapidamente
+ **Ferramenta de aprendizagem:** veja as configurações geradas e entenda como o Application Signals funciona
### Recursos adicionais
Para saber mais sobre a configuração e o uso do servidor MCP do CloudWatch Application Signals, consulte a [documentação do servidor MCP](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).
## (Opcional) Monitorar a integridade da aplicação
Depois de habilitar as aplicações no Amazon EC2, você pode monitorar a integridade da aplicação. Para obter mais informações, consulte [Monitorar a integridade operacional das suas aplicações com o Application Signals](Services.md).