Passaggio 1: abilitazione di Application Signals nell'account Passaggio 2: scarica e avvia l' CloudWatch agente Passaggio 3: instrumentazione e avvio dell'applicazione Abilita i segnali applicativi su Amazon EC2 utilizzando Model Context Protocol (MCP)(Facoltativo) Monitoraggio dell'integrità delle applicazioni

Abilita le tue applicazioni su Amazon EC2

Abilita CloudWatch Application Signals su Amazon EC2 utilizzando i passaggi di configurazione personalizzati descritti in questa sezione.

Per le applicazioni in esecuzione su Amazon EC2, puoi installare e configurare OpenTelemetry autonomamente l' CloudWatch agente e AWS Distro. Su queste architetture abilitate con una configurazione personalizzata di Application Signals, Application Signals non rileva automaticamente i nomi dei tuoi servizi o dei cluster o host su cui vengono eseguiti. Devi specificare questi nomi durante la configurazione personalizzata e i nomi specificati sono quelli visualizzati nei pannelli di controllo di Application Signals.

Le istruzioni in questa sezione si riferiscono alle applicazioni Java, Python e .NET. I passaggi sono stati testati su EC2 istanze Amazon, ma si prevede che funzionino anche su altre architetture che supportano AWS Distro for. OpenTelemetry

Requisiti

Per ottenere supporto per Application Signals, devi utilizzare la versione più recente sia dell' CloudWatchagente che di Distro for agent. AWS OpenTelemetry
È necessario che AWS CLI sia installato sull'istanza. Consigliamo AWS CLI la versione 2, ma dovrebbe funzionare anche la versione 1. Per ulteriori informazioni sull'installazione di AWS CLI, consulta Installare o aggiornare la versione più recente di AWS CLI.

Importante

Se stai già utilizzando OpenTelemetry un'applicazione che intendi abilitare per Application Signals, consulta Sistemi supportati prima di abilitare Application Signals.

Passaggio 1: abilitazione di Application Signals nell'account

Prima devi abilitare Application Signals nel tuo account. Se non lo hai ancora fatto, consulta Abilitazione di Application Signals in un account.

Passaggio 2: scarica e avvia l' CloudWatch agente

Per installare l' CloudWatch agente come parte dell'abilitazione di Application Signals su un' EC2 istanza Amazon o un host locale

Scarica la versione più recente dell' CloudWatch agente sull'istanza. Se l' CloudWatch agente è già installato sull'istanza, potrebbe essere necessario aggiornarlo. Solo le versioni dell'agente rilasciate il 30 novembre 2023 o successive supportano CloudWatch Application Signals.
Prima di avviare l' CloudWatch agente, configuralo per abilitare Application Signals. L'esempio seguente è una configurazione di CloudWatch agente che abilita Application Signals sia per le metriche che per le tracce su un EC2 host.

Ti consigliamo di collocare questo file in /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json sui sistemi Linux.
```
{
  "traces": {
    "traces_collected": {
      "application_signals": {}
    }
  },
  "logs": {
    "metrics_collected": {
      "application_signals": {}
    }
  }
}
```
Collega la policy CloudWatchAgentServerPolicyIAM al ruolo IAM della tua EC2 istanza Amazon. Per le autorizzazioni per gli host on-premises, consulta Autorizzazioni per server on-premises.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
2. Scegli Ruoli e trova il ruolo utilizzato dalla tua EC2 istanza Amazon. Quindi scegli il nome del ruolo.
3. Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, quindi Collega policy.
4. Trova CloudWatchAgentServerPolicy. Usa la casella di ricerca se necessario. Quindi seleziona la casella di controllo della policy e seleziona Aggiungi autorizzazioni.
Avvia l' CloudWatch agente inserendo i seguenti comandi. Sostituisci agent-config-file-path con il percorso del file di configurazione CloudWatch dell'agente, ad esempio./amazon-cloudwatch-agent.json. È necessario includere il prefisso file: come mostrato.
```
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
```

Autorizzazioni per server on-premises

Per un host locale, dovrai fornire AWS l'autorizzazione al tuo dispositivo.

Per impostare le autorizzazioni per un host on-premises

Crea l'utente IAM da utilizzare per fornire le autorizzazioni al tuo host on-premises:
1. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
2. Scegli Utenti, quindi seleziona Crea utente.
3. In Dettagli utente, per Nome utente, inserisci un nome per il nuovo utente IAM. Questo è il nome di accesso AWS che verrà utilizzato per autenticare l'host. quindi scegliere Next.
4. Nella pagina Imposta autorizzazioni, nel campo Opzioni delle autorizzazioni, scegli Collega direttamente le policy.
5. Dall'elenco delle politiche di autorizzazione, seleziona la CloudWatchAgentServerPolicypolitica da aggiungere al tuo utente. Quindi scegli Successivo.
6. Nella pagina Rivedi e crea, assicurati di essere soddisfatto del nome utente e che la CloudWatchAgentServerPolicypolitica sia inclusa nel riepilogo delle autorizzazioni.
7. Scegli Crea utente.
Crea e recupera la tua chiave di AWS accesso e la chiave segreta:
1. Nel pannello di navigazione della console IAM, scegli Utenti e seleziona il nome utente dell'utente creato nel passaggio precedente.
2. Nella pagina dell'utente, scegli la scheda Credenziali di sicurezza. Quindi, nella sezione Chiavi di accesso, scegli Crea chiave di accesso.
3. Per Crea chiave di accesso (passaggio 1), scegli Interfaccia a riga di comando (CLI).
4. Per Crea chiave di accesso (passaggio 2), inserisci facoltativamente un tag e scegli Avanti.
5. Per Crea chiave di accesso (passaggio 3), seleziona Scarica il file .csv per salvare un file .csv con la chiave di accesso e la chiave di accesso segreta del tuo utente IAM. Queste informazioni serviranno per i passaggi successivi.
6. Seleziona Fatto.
Configura AWS le tue credenziali nel tuo host locale inserendo il seguente comando. Sostituisci ACCESS_KEY_ID e SECRET_ACCESS_ID con la chiave di accesso appena generata e la chiave di accesso segreta dal file.csv scaricato nel passaggio precedente.
```
$ 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
```

Passaggio 3: instrumentazione e avvio dell'applicazione

Il passo successivo consiste nello strumentare la vostra CloudWatch applicazione per Application Signals.

Java

Per strumentare le tue applicazioni Java come parte dell'abilitazione di Application Signals su un' EC2 istanza Amazon o un host locale

Scarica l'ultima versione dell'agente di strumentazione automatica AWS Distro for OpenTelemetry Java. Puoi scaricare la versione più recente utilizzando questo link. È possibile visualizzare informazioni su tutte le versioni rilasciate in Releases. aws-otel-java-instrumentation
Per ottimizzare i vantaggi di Application Signals, utilizza le variabili di ambiente per fornire informazioni aggiuntive prima di avviare l'applicazione. Queste informazioni verranno visualizzate nei pannelli di controllo di Application Signals.
1. Per la variabile OTEL_RESOURCE_ATTRIBUTES, specifica le seguenti informazioni come coppie chiave-valore:
  - (Facoltativo) service.name imposta il nome del servizio. Questo verrà visualizzato come nome del servizio per l'applicazione nei pannelli di controllo di Application Signals. Se non si fornisce un valore per questa chiave, viene utilizzato il valore predefinito di UnknownService.
  - (Facoltativo) deployment.environment imposta l'ambiente in cui viene eseguita l'applicazione. Questo verrà visualizzato come ambiente ospitato dell'applicazione nei pannelli di controllo di Application Signals. Se non si specifica un'opzione, viene utilizzata una delle impostazioni predefinite riportate di seguito:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostato su ec2:name-of-Auto-Scaling-group
    Se si tratta di un' EC2 istanza Amazon che non fa parte di un gruppo Auto Scaling, è impostata su ec2:default
    Se si tratta di un host on-premises, è impostato su generic:default
    Questa variabile di ambiente viene utilizzata solo da Application Signals e viene convertita in annotazioni di tracce a raggi X e CloudWatch dimensioni metriche.
  - Per la variabile OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare le tracce. L' CloudWatch agente espone 4316 come porta OTLP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
  - Per la variabile OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare i parametri. L' CloudWatch agente espone 4316 come porta OTLP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
  - Per la JAVA_TOOL_OPTIONS variabile, specificare il percorso in cui è archiviato l'agente di strumentazione automatica AWS Distro for OpenTelemetry Java.
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
```
    Ad esempio:
```
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH=./aws-opentelemetry-agent.jar
```
  - Per la variabile OTEL_METRICS_EXPORTER, si consiglia di impostare il valore su none. Questa operazione disabilita gli esportatori di altri parametri in modo che venga utilizzato solo l'esportatore Application Signals.
  - Imposta OTEL_AWS_APPLICATION_SIGNALS_ENABLED su true. Questo genera i parametri di Application Signals a partire dalle tracce.

Avvia l'applicazione con le variabili di ambiente elencate nel passaggio precedente. Di seguito è riportato un esempio di script di avvio.

Nota

La seguente configurazione supporta solo le versioni 1.32.2 e successive dell'agente AWS Distro for OpenTelemetry auto-instrumentation for 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

(Facoltativo) Per abilitare la correlazione dei log, in OTEL_RESOURCE_ATTRIBUTES, imposta una variabile di ambiente aggiuntiva aws.log.group.names per i gruppi di log dell'applicazione. In questo modo, le tracce e le metriche dell'applicazione possono essere correlate alle voci di log pertinenti di questi gruppi di log. Per questa variabile, sostituisci $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare una e commerciale (&) per separarli come in questo esempio: aws.log.group.names=log-group-1&log-group-2. Per abilitare la correlazione tra metrica e log, è sufficiente impostare questa variabile di ambiente corrente. Per ulteriori informazioni, consulta Abilitazione della correlazione tra metrica e log. Per abilitare la correlazione tra traccia e log, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilitazione della correlazione tra traccia e log.

Di seguito è riportato un esempio di script di avvio che consente di abilitare la correlazione dei log.
```
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 stai usando un server WSGI per l'applicazione Python, oltre ai passaggi successivi di questa sezione, consulta Nessun dato di Application Signals per l'applicazione Python che utilizza un server WSGI per informazioni sull'abilitazione di Application Signals.

Per strumentare le tue applicazioni Python come parte dell'abilitazione di Application Signals su un'istanza Amazon EC2

Scarica l'ultima versione dell'agente di AWS strumentazione automatica Distro for OpenTelemetry Python. Installarlo eseguendo il seguente comando .
```
pip install aws-opentelemetry-distro
```
È possibile visualizzare informazioni su tutte le versioni rilasciate nella AWS strumentazione Distro for OpenTelemetry Python.
Per ottimizzare i vantaggi di Application Signals, utilizza le variabili di ambiente per fornire informazioni aggiuntive prima di avviare l'applicazione. Queste informazioni verranno visualizzate nei pannelli di controllo di Application Signals.
1. Per la variabile OTEL_RESOURCE_ATTRIBUTES, specifica le seguenti informazioni come coppie chiave-valore:
  - service.name imposta il nome del servizio. Questo verrà visualizzato come nome del servizio per l'applicazione nei pannelli di controllo di Application Signals. Se non si fornisce un valore per questa chiave, viene utilizzato il valore predefinito di UnknownService.
  - deployment.environment imposta l'ambiente in cui viene eseguita l'applicazione. Questo verrà visualizzato come ambiente ospitato dell'applicazione nei pannelli di controllo di Application Signals. Se non si specifica un'opzione, viene utilizzata una delle impostazioni predefinite riportate di seguito:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostato su ec2:name-of-Auto-Scaling-group.
    Se si tratta di un' EC2 istanza Amazon che non fa parte di un gruppo Auto Scaling, è impostata su ec2:default
    Se si tratta di un host on-premises, è impostato su generic:default
    Questa chiave di attributo viene utilizzata solo da Application Signals e viene convertita in annotazioni di tracce a raggi X e CloudWatch dimensioni metriche.
2. Per la OTEL_EXPORTER_OTLP_PROTOCOL variabile, specificate di http/protobuf esportare i dati di telemetria tramite HTTP negli endpoint dell' CloudWatch agente elencati nei passaggi seguenti.
3. Per la variabile OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare le tracce. L' CloudWatch agente espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Per la variabile OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare i parametri. L' CloudWatch agente espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Per la variabile OTEL_METRICS_EXPORTER, si consiglia di impostare il valore su none. Questa operazione disabilita gli esportatori di altri parametri in modo che venga utilizzato solo l'esportatore Application Signals.
6. Imposta la OTEL_AWS_APPLICATION_SIGNALS_ENABLED variabile in modo che il contenitore inizi true a inviare tracce e CloudWatch metriche X-Ray a Application Signals.
Avvia l'applicazione con le variabili di ambiente illustrate nel passaggio precedente. Di seguito è riportato un esempio di script di avvio.
- Sostituisci $SVC_NAME con il nome della tua applicazione. Questo verrà visualizzato come nome dell'applicazione nei pannelli di controllo di Application Signals.
- Sostituisci $PYTHON_APP con la posizione e il nome della tua applicazione.
```
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
```
Prima di abilitare Application Signals per le applicazioni Python, tieni presente le considerazioni riportate di seguito.
- In alcune applicazioni containerizzate, l'assenza della variabile di ambiente PYTHONPATH può talvolta impedire l'avvio dell'applicazione. Per risolvere questo problema, assicurati di impostare la variabile di ambiente PYTHONPATH sulla posizione della directory di lavoro dell'applicazione. Ciò è dovuto a un problema noto con la OpenTelemetry strumentazione automatica. Per ulteriori informazioni su questo problema, consulta Python autoinstrumentation setting of PYTHONPATH is not compliant.
- Per le applicazioni Django, ci sono configurazioni aggiuntive richieste, che sono descritte nella documentazione di Python OpenTelemetry .
  - Usa il flag --noreload per impedire il ricaricamento automatico.
  - Imposta la variabile di ambiente DJANGO_SETTINGS_MODULE sulla posizione del file settings.py dell'applicazione Django. Ciò garantisce che OpenTelemetry possa accedere e integrarsi correttamente con le impostazioni di Django.
(Facoltativo) Per abilitare la correlazione dei log, in OTEL_RESOURCE_ATTRIBUTES, imposta una variabile di ambiente aggiuntiva aws.log.group.names per i gruppi di log dell'applicazione. In questo modo, le tracce e le metriche dell'applicazione possono essere correlate alle voci di log pertinenti di questi gruppi di log. Per questa variabile, sostituisci $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare una e commerciale (&) per separarli come in questo esempio: aws.log.group.names=log-group-1&log-group-2. Per abilitare la correlazione tra metrica e log, è sufficiente impostare questa variabile di ambiente corrente. Per ulteriori informazioni, consulta Abilitazione della correlazione tra metrica e log. Per abilitare la correlazione tra traccia e log, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilitazione della correlazione tra traccia e log.

Di seguito è riportato un esempio di script di avvio che consente di abilitare la correlazione dei log.
```
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

Per strumentare le tue applicazioni.NET come parte dell'abilitazione di Application Signals su un' EC2 istanza Amazon o un host locale

Scarica l'ultima versione del pacchetto di strumentazione automatica AWS Distro for OpenTelemetry .NET. È possibile scaricare la versione più recente alla pagina Releases. aws-otel-dotnet-instrumentation

Per abilitare Application Signals, imposta le seguenti variabili di ambiente per fornire informazioni aggiuntive prima di avviare l'applicazione. Queste variabili sono necessarie per configurare l'hook di avvio per l'instrumentazione .NET prima di avviare l'applicazione .NET. Sostituisci dotnet-service-name nella variabile di ambiente OTEL_RESOURCE_ATTRIBUTES con il nome di servizio che preferisci.

Di seguito è riportato un esempio per 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

Di seguito è riportato un esempio per 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"

Avvia l'applicazione con le variabili di ambiente elencate nel passaggio precedente.

(Facoltativo) In alternativa, è possibile utilizzare gli script di installazione forniti per facilitare l'installazione e la configurazione del pacchetto di strumentazione automatica AWS Distro for OpenTelemetry .NET.

Per Linux, scarica e installa lo script di installazione di Bash dalla pagina delle versioni: 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

Per Windows Server, scarica e installa lo script di PowerShell installazione dalla pagina delle GitHub versioni:


# 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

Puoi trovare il NuGet pacchetto del pacchetto di strumentazione automatica AWS Distro for OpenTelemetry .NET nel repository ufficiale. NuGet Assicurati di controllare le istruzioni contenute nel file README.

Node.js

Nota

Se stai abilitando Application Signals per un'applicazione Node.js con ESM, consulta Setting up a Node.js application with the ESM module format prima di iniziare questi passaggi.

Per strumentare le tue applicazioni Node.js come parte dell'abilitazione di Application Signals su un' EC2 istanza Amazon

Scarica l'ultima versione dell'agente AWS Distro for OpenTelemetry JavaScript auto-instrumentation for Node.js. Installarlo eseguendo il seguente comando .
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
È possibile visualizzare informazioni su tutte le versioni rilasciate su Distro for instrumentation AWS . OpenTelemetry JavaScript
Per ottimizzare i vantaggi di Application Signals, utilizza le variabili di ambiente per fornire informazioni aggiuntive prima di avviare l'applicazione. Queste informazioni verranno visualizzate nei pannelli di controllo di Application Signals.
1. Per la variabile OTEL_RESOURCE_ATTRIBUTES, specifica le seguenti informazioni come coppie chiave-valore:
  - service.name imposta il nome del servizio. Questo verrà visualizzato come nome del servizio per l'applicazione nei pannelli di controllo di Application Signals. Se non si fornisce un valore per questa chiave, viene utilizzato il valore predefinito di UnknownService.
  - deployment.environment imposta l'ambiente in cui viene eseguita l'applicazione. Questo verrà visualizzato come ambiente ospitato dell'applicazione nei pannelli di controllo di Application Signals. Se non si specifica un'opzione, viene utilizzata una delle impostazioni predefinite riportate di seguito:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostato su ec2:name-of-Auto-Scaling-group.
    Se si tratta di un' EC2 istanza Amazon che non fa parte di un gruppo Auto Scaling, è impostata su ec2:default
    Se si tratta di un host on-premises, è impostato su generic:default
    Questa chiave di attributo viene utilizzata solo da Application Signals e viene convertita in annotazioni di tracce a raggi X e CloudWatch dimensioni metriche.
2. Per la OTEL_EXPORTER_OTLP_PROTOCOL variabile, specificate di http/protobuf esportare i dati di telemetria tramite HTTP negli endpoint dell' CloudWatch agente elencati nei passaggi seguenti.
3. Per la variabile OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare le tracce. L' CloudWatch agente espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Per la variabile OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare i parametri. L' CloudWatch agente espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l' CloudWatch agente locale, è necessario impostare questo valore su OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Per la variabile OTEL_METRICS_EXPORTER, si consiglia di impostare il valore su none. Questa operazione disabilita gli esportatori di altri parametri in modo che venga utilizzato solo l'esportatore Application Signals.
6. Imposta la OTEL_AWS_APPLICATION_SIGNALS_ENABLED variabile in modo che il contenitore inizi true a inviare tracce e CloudWatch metriche X-Ray a Application Signals.

Avvia l'applicazione con le variabili di ambiente illustrate nel passaggio precedente. Di seguito è riportato un esempio di script di avvio.

Sostituisci $SVC_NAME con il nome della tua applicazione. Questo verrà visualizzato come nome dell'applicazione nei pannelli di controllo di 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

(Facoltativo) Per abilitare la correlazione dei log, in OTEL_RESOURCE_ATTRIBUTES, imposta una variabile di ambiente aggiuntiva aws.log.group.names per i gruppi di log dell'applicazione. In questo modo, le tracce e le metriche dell'applicazione possono essere correlate alle voci di log pertinenti di questi gruppi di log. Per questa variabile, sostituisci $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare una e commerciale (&) per separarli come in questo esempio: aws.log.group.names=log-group-1&log-group-2. Per abilitare la correlazione tra metrica e log, è sufficiente impostare questa variabile di ambiente corrente. Per ulteriori informazioni, consulta Abilitazione della correlazione tra metrica e log. Per abilitare la correlazione tra traccia e log, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilitazione della correlazione tra traccia e log.

Di seguito è riportato un esempio di script di avvio che consente di abilitare la correlazione dei log.
```
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
```

Configurazione di un'applicazione Node.js con il formato del modulo ESM

Forniamo un supporto limitato per le applicazioni Node.js con il formato del modulo ESM. Per informazioni dettagliate, vedi Limitazioni note di Node.js con ESM.

Per abilitare Application Signals per un'applicazione Node.js con ESM, è necessario modificare i passaggi della procedura precedente.

Innanzitutto, installa @opentelemetry/instrumentation per la tua applicazione Node.js:


npm install @opentelemetry/instrumentation@0.54.0

Quindi, nei passaggi 3 e 4 della procedura precedente, modifica le opzioni del nodo da:


--require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register'

ai valori seguenti:


--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs

Abilita i segnali applicativi su Amazon EC2 utilizzando Model Context Protocol (MCP)

Puoi utilizzare il server CloudWatch Application Signals Model Context Protocol (MCP) per abilitare Application Signals sulle tue EC2 istanze Amazon tramite interazioni IA conversazionali. Ciò fornisce un'interfaccia in linguaggio naturale per configurare il monitoraggio di Application Signals.

Il server MCP automatizza il processo di abilitazione comprendendo i requisiti dell'utente e generando la configurazione appropriata. Invece di seguire manualmente i passaggi di configurazione, puoi semplicemente descrivere cosa vuoi abilitare.

Prerequisiti

Prima di utilizzare il server MCP per abilitare Application Signals, assicuratevi di avere:

Un ambiente di sviluppo che supporti MCP (come Kiro, Claude Desktop, VSCode con estensioni MCP o altri strumenti compatibili con MCP)
Il server MCP CloudWatch Application Signals configurato nel tuo IDE. Per istruzioni di configurazione dettagliate, consultate la documentazione del server MCP di CloudWatch Application Signals.

Utilizzo del server MCP

Dopo aver configurato il server MCP CloudWatch Application Signals nell'IDE, puoi richiedere indicazioni sull'abilitazione utilizzando istruzioni in linguaggio naturale. Sebbene l'assistente di codifica sia in grado di dedurre il contesto dalla struttura del progetto, fornire dettagli specifici nelle istruzioni aiuta a garantire una guida più accurata e pertinente. Includi informazioni come il linguaggio dell'applicazione, i dettagli dell'istanza e i percorsi assoluti dell'infrastruttura e del codice dell'applicazione.

Suggerimenti sulle migliori pratiche (specifici e completi):


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

Suggerimenti meno efficaci:


"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

Modello rapido:


"Enable Application Signals for my [LANGUAGE] service on EC2.
App code: [ABSOLUTE_PATH_TO_APP]
IaC code: [ABSOLUTE_PATH_TO_IAC]"

Vantaggi dell'utilizzo del server MCP

L'utilizzo del server MCP CloudWatch Application Signals offre diversi vantaggi:

Interfaccia in linguaggio naturale: descrivi cosa vuoi abilitare senza memorizzare comandi o sintassi di configurazione
Guida sensibile al contesto: il server MCP comprende l'ambiente specifico dell'utente e fornisce consigli personalizzati
Errori ridotti: la generazione automatizzata della configurazione riduce al minimo gli errori di digitazione manuale
Configurazione più rapida: passa più rapidamente dall'intenzione all'implementazione
Strumento di apprendimento: guarda le configurazioni generate e scopri come funziona Application Signals

Per ulteriori informazioni sulla configurazione e l'utilizzo del server MCP CloudWatch Application Signals, consultate la documentazione del server MCP.

(Facoltativo) Monitoraggio dell'integrità delle applicazioni

Dopo aver abilitato le applicazioni su Amazon EC2, puoi monitorare lo stato delle applicazioni. Per ulteriori informazioni, consulta Monitoraggio dell'integrità operativa delle applicazioni con Application Signals.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Abilitazione delle applicazioni sui cluster Amazon EKS

Abilitazione delle applicazioni in Amazon ECS