Fase 1: abilitazione di Application Signals nel tuo account Passaggio 2: scarica e avvia l' CloudWatch agente Fase 3: strumentazione e avvio dell'applicazione (Facoltativo) Fase 4: Monitoraggio dello stato dell'applicazione

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 OpenTelemetry compatibilità prima di abilitare Application Signals.

Fase 1: abilitazione di Application Signals nel tuo account

Devi prima abilitare Application Signals nel tuo account. Se non l'hai fatto, vediAbilita Application Signals nel tuo 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.

Per informazioni sul download dell' CloudWatch agente, consultaScarica il pacchetto dell' CloudWatch agente.
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.

Si consiglia di inserire questo file /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json in 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 locali, consulta. Autorizzazioni per i server locali
1. Accedi AWS Management Console 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 i server locali

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

Per configurare le autorizzazioni per un host locale

Crea l'utente IAM da utilizzare per fornire le autorizzazioni al tuo host locale:
1. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
2. Scegli Utenti, Crea utente.
3. In Dettagli utente, in Nome utente, inserisci un nome per il nuovo utente IAM. Questo è il nome di accesso AWS che verrà utilizzato per autenticare il tuo host. quindi scegliere Next.
4. Nella pagina Imposta le autorizzazioni, in Opzioni di autorizzazione, seleziona Allega direttamente le politiche.
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 riquadro di navigazione della console IAM, scegli Utenti, quindi seleziona il nome utente dell'utente che hai 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 Creare la chiave di accesso Step 1, scegli Command Line Interface (CLI).
4. Per la creazione della chiave di accesso (Passaggio 2), inserisci facoltativamente un tag e scegli Avanti.
5. Per la fase 3 di creazione della chiave di accesso, 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 ti servono per i passaggi successivi.
6. Seleziona Fatto.
Configura AWS le tue credenziali nell'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
```

Fase 3: strumentazione 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 dashboard 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 lo specificate, viene utilizzata una delle seguenti impostazioni predefinite:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostata 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 locale, è 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"
```
    Per 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.

Avviate 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 logOTEL_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 registro pertinenti di questi gruppi di log. Per questa variabile, sostituitela $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare un ampersand (&) 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 ambientale corrente. Per ulteriori informazioni, consulta Abilita la correlazione tra metrica e log. Per abilitare la correlazione tra traccia e registro, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilita la correlazione tra traccia e registro.

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 la tua applicazione Python, oltre ai seguenti passaggi in questa sezione, Nessun dato di Application Signals per l'applicazione Python che utilizza un server WSGI consulta per informazioni su come far funzionare 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 lo specificate, viene utilizzata una delle seguenti impostazioni predefinite:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostata 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 locale, è 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, nelle dashboard di Application Signals.
- Sostituiscilo $PYTHON_APP con la posizione e il nome dell'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 tue applicazioni Python, tieni presente le seguenti considerazioni.
- In alcune applicazioni containerizzate, una variabile di PYTHONPATH ambiente mancante a volte può impedire l'avvio dell'applicazione. Per risolvere questo problema, assicuratevi di impostare la variabile di PYTHONPATH ambiente 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, vedere L'impostazione della strumentazione automatica in Python di PYTHONPATH non è conforme.
- Per le applicazioni Django, ci sono configurazioni aggiuntive richieste, che sono descritte nella documentazione di Python OpenTelemetry .
  - Usa il --noreload flag per impedire il ricaricamento automatico.
  - Imposta la variabile di DJANGO_SETTINGS_MODULE ambiente sulla posizione del file dell'settings.pyapplicazione Django. Ciò garantisce che OpenTelemetry possa accedere e integrarsi correttamente con le impostazioni di Django.
(Facoltativo) Per abilitare la correlazione dei logOTEL_RESOURCE_ATTRIBUTES, imposta una variabile di ambiente aggiuntiva aws.log.group.names per i gruppi di log della tua applicazione. In questo modo, le tracce e le metriche dell'applicazione possono essere correlate alle voci di registro pertinenti di questi gruppi di log. Per questa variabile, sostituitela $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare un ampersand (&) 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 ambientale corrente. Per ulteriori informazioni, consulta Abilita la correlazione tra metrica e log. Per abilitare la correlazione tra traccia e registro, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilita la correlazione tra traccia e registro.

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 la strumentazione.NET prima di avviare l'applicazione.NET. Sostituiscile dotnet-service-name nella variabile di OTEL_RESOURCE_ATTRIBUTES ambiente con il nome di servizio di tua scelta.

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"

Avviate 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 il file README per le istruzioni.

Node.js

Nota

Se state abilitando Application Signals per un'applicazione Node.js con ESM, consultate 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 lo specificate, viene utilizzata una delle seguenti impostazioni predefinite:
    Se si tratta di un'istanza che fa parte di un gruppo Auto Scaling, è impostata 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 locale, è 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, nelle dashboard 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 logOTEL_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 registro pertinenti di questi gruppi di log. Per questa variabile, sostituitela $YOUR_APPLICATION_LOG_GROUP con i nomi dei gruppi di log dell'applicazione. Se hai più gruppi di log, puoi usare un ampersand (&) 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 ambientale corrente. Per ulteriori informazioni, consulta Abilita la correlazione tra metrica e log. Per abilitare la correlazione tra traccia e registro, dovrai anche modificare la configurazione di registrazione nell'applicazione. Per ulteriori informazioni, consulta Abilita la correlazione tra traccia e registro.

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, consultare Limitazioni note relative a 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, modificate le opzioni del nodo da:


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

a quanto segue:


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

(Facoltativo) Fase 4: Monitoraggio dello stato dell'applicazione

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

Abilita le tue applicazioni sui cluster Amazon EKS

Abilita le tue applicazioni su Amazon ECS