Fase 1: abilitazione di Application Signals nel tuo account Fase 2: download e avvio dell'agente CloudWatch Passaggio 3: instrumentazione e avvio dell'applicazione (Facoltativo) Passaggio 4: monitoraggio dell'integrità delle applicazioni

Abilitazione delle applicazioni in Amazon EC2

Abilita CloudWatch Application Signals su Amazon EC2 utilizzando la procedura di configurazione personalizzata descritta in questa sezione.

Per le applicazioni in esecuzione su Amazon EC2, puoi installare e configurare in autonomia l'agente CloudWatch e AWS Distro per OpenTelemetry. 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. Le procedure sono state testate su istanze Amazon EC2, ma dovrebbero funzionare anche su altre architetture che supportano AWS Distro per OpenTelemetry.

Requisiti

Per ottenere supporto per Application Signals, devi utilizzare la versione più recente sia dell'agente CloudWatch che dell'agente AWS Distro for OpenTelemetry.
È necessario avere installato la AWS CLI nell'istanza. Consigliamo AWS CLI versione 2, ma dovrebbe funzionare anche la versione 1. Per informazioni sull'installazione della AWS CLI, consulta Installazione o aggiornamento della versione più recente della AWS CLI.

Importante

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

Fase 1: abilitazione di Application Signals nel tuo account

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

Fase 2: download e avvio dell'agente CloudWatch

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

Scarica la versione più recente dell'agente CloudWatch per l'istanza. Se l'agente CloudWatch è già installato nell'istanza, potresti doverlo aggiornare. Solo le versioni dell'agente rilasciate il 30 novembre 2023 o successivamente supportano CloudWatch Application Signals.
Prima di avviare l'agente CloudWatch, configuralo per abilitare Application Signals. L'esempio seguente è una configurazione dell'agente CloudWatch che abilita Application Signals sia per i parametri che per le tracce su un host EC2.

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 IAM CloudWatchAgentServerPolicy al ruolo IAM della tua istanza Amazon EC2. Per le autorizzazioni per gli host on-premises, consulta Autorizzazioni per server on-premises.
1. Accedi a 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 istanza Amazon EC2. 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'agente CloudWatch inserendo i comandi seguenti. Sostituisci agent-config-file-path con il percorso del file di configurazione dell'agente di CloudWatch, 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 on-premises, dovrai fornire al tuo dispositivo l'autorizzazione AWS.

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 per AWS che verrà utilizzato per autenticare il tuo host. quindi scegliere Next.
4. Nella pagina Imposta autorizzazioni, nel campo Opzioni delle autorizzazioni, scegli Collega direttamente le policy.
5. Dall'elenco Policy di autorizzazione, seleziona la policy CloudWatchAgentServerPolicy da aggiungere all'utente. Quindi scegli Successivo.
6. Nella pagina Rivedi e crea, verifica la correttezza del nome utente e che la policy CloudWatchAgentServerPolicy sia inclusa nel Riepilogo delle autorizzazioni.
7. Scegli Crea utente.
Crea e recupera la chiave di accesso AWS 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 le credenziali AWS nell'host on-premises immettendo il seguente comando. Sostituisci ACCESS_KEY_ID e SECRET_ACCESS_ID con la chiave di accesso e la chiave di accesso segreta appena generate 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 passaggio successivo è quello di instrumentare l'applicazione per CloudWatch Application Signals.

Java

Per instrumentare le tue applicazioni Java come parte dell'abilitazione di Application Signals su un'istanza Amazon EC2 o un host on-premises

Scarica l'ultima versione dell'agente di strumentazione automatica Java di AWS Distro per OpenTelemetry. Puoi scaricare la versione più recente utilizzando questo link. Puoi visualizzare informazioni su tutte le versioni rilasciate sui rilasci 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'istanza Amazon EC2 che non fa parte di un gruppo Auto Scaling, è impostato 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 X-Ray e dimensioni delle metriche CloudWatch.
  - Per la variabile OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, specifica l'URL dell'endpoint di base in cui esportare le tracce. L'agente CloudWatch espone 4316 come porta OTLP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch 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'agente CloudWatch espone 4316 come porta OTLP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch locale, è necessario impostare questo valore su OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
  - Per la variabile JAVA_TOOL_OPTIONS, specifica il percorso in cui è archiviato l'agente di strumentazione automatica Java di AWS Distro per OpenTelemetr.
```
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.

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 di instrumentazione automatica AWS Distro per OpenTelemetry per 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 instrumentare le tue applicazioni Python come parte dell'abilitazione di Application Signals su un'istanza Amazon EC2

Scarica l'ultima versione dell'agente di instrumentazione automatica Python di AWS Distro per OpenTelemetry. Installarlo eseguendo il seguente comando .
```
pip install aws-opentelemetry-distro
```
Puoi visualizzare informazioni su tutte le versioni rilasciate alla pagina Instrumentazione di AWS Distro per 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'istanza Amazon EC2 che non fa parte di un gruppo Auto Scaling, è impostato 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 X-Ray e dimensioni dei parametri CloudWatch.
2. Per la variabile OTEL_EXPORTER_OTLP_PROTOCOL, specifica http/protobuf per esportare i dati di telemetria tramite HTTP negli endpoint dell'agente CloudWatch 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'agente CloudWatch espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch 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'agente CloudWatch espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch 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 variabile OTEL_AWS_APPLICATION_SIGNALS_ENABLED su true affinché il container inizi a inviare tracce X-Ray e metriche CloudWatch ad 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 l'instrumentazione automatica di OpenTelemetry. Per ulteriori informazioni su questo problema, consulta Python autoinstrumentation setting of PYTHONPATH is not compliant.
- Per le applicazioni Django sono richieste alcune configurazioni aggiuntive, che sono descritte nella documentazione di OpenTelemetry Python.
  - 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 instrumentare le tue applicazioni .NET come parte dell'abilitazione di Application Signals su un'istanza Amazon EC2 o un host on-premises

Scarica l'ultima versione del pacchetto di instrumentazione automatica di AWS Distro per OpenTelemetry .NET. Puoi scaricare l'ultima versione dalla pagina aws-otel-dotnet-instrumentation Releases.

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 instrumentazione automatica .NET di AWS Distro per OpenTelemetry.

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

È possibile trovare il pacchetto NuGet della instrumentazione automatica .NET di AWS Distro per OpenTelemetry nel repository NuGet ufficiale. 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 instrumentare le tue applicazioni Node.js come parte dell'abilitazione di Application Signals su un'istanza Amazon EC2

Scarica l'ultima versione dell'agente di instrumentazione automatica JavaScript di AWS Distro per OpenTelemetry per Node.js. Installarlo eseguendo il seguente comando .
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
Puoi visualizzare informazioni su tutte le versioni rilasciate alla pagina Instrumentazione di AWS Distro per 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'istanza Amazon EC2 che non fa parte di un gruppo Auto Scaling, è impostato 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 X-Ray e dimensioni dei parametri CloudWatch.
2. Per la variabile OTEL_EXPORTER_OTLP_PROTOCOL, specifica http/protobuf per esportare i dati di telemetria tramite HTTP negli endpoint dell'agente CloudWatch 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'agente CloudWatch espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch 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'agente CloudWatch espone 4316 come porta OTLP su HTTP. Su Amazon EC2, poiché le applicazioni comunicano con l'agente CloudWatch 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 variabile OTEL_AWS_APPLICATION_SIGNALS_ENABLED su true affinché il container inizi a inviare tracce X-Ray e metriche CloudWatch ad 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, consultare 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

(Facoltativo) Passaggio 4: monitoraggio dell'integrità delle applicazioni

Dopo aver abilitato le applicazioni su Amazon EC2, è possibile monitorarne l'integrità. 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