Schritt 1: Application Signals in Ihrem Konto aktivieren Schritt 2: Laden Sie den Agenten herunter und starten Sie ihn CloudWatch Schritt 3: Ihre Anwendung instrumentieren und starten

Anwendungssignale auf Amazon aktivieren EC2

Für Anwendungen, die auf Amazon EC2 oder anderen Instance-Typen ausgeführt werden, installieren und konfigurieren Sie den CloudWatch Agenten und die AWS Distribution OpenTelemetry selbst. Auf diesen Architekturen, die mit einer benutzerdefinierten Einrichtung von Application Signals aktiviert wurden, erkennt Application Signals die Namen Ihrer Services oder deren Cluster oder Hosts nicht automatisch. Sie müssen diese Namen bei der benutzerdefinierten Einrichtung angeben, und die Namen, die Sie angeben, werden auf den Dashboards von Application Signals angezeigt.

Die Anweisungen in diesem Abschnitt beziehen sich auf Java-, Python- und .NET-Anwendungen. Die Schritte wurden auf EC2 Amazon-Instances getestet, es wird jedoch erwartet, dass sie auch auf anderen Architekturen funktionieren, für die AWS Distro unterstützt wird. OpenTelemetry

Voraussetzungen

Um Unterstützung für Application Signals zu erhalten, müssen Sie die neueste Version sowohl des Agenten als auch der AWS Distribution for CloudWatch Agent verwenden. OpenTelemetry
Sie müssen den auf der Instanz AWS CLI installiert haben. Wir empfehlen AWS CLI Version 2, aber Version 1 sollte auch funktionieren. Weitere Informationen zur Installation von finden Sie unter Installieren oder Aktualisieren der neuesten Version von AWS CLI. AWS CLI

Wichtig

Wenn Sie bereits eine Anwendung verwenden OpenTelemetry , die Sie für Application Signals aktivieren möchten, finden Sie weitere Informationen, OpenTelemetry Kompatibilität bevor Sie Application Signals aktivieren.

Schritt 1: Application Signals in Ihrem Konto aktivieren

Wenn Sie Application Signals in diesem Konto noch nicht aktiviert haben, müssen Sie Application Signals die Berechtigungen gewähren, die es benötigt, um Ihre Services zu erkennen. Gehen Sie dazu wie folgt vor. Dies muss nur einmal für Ihr Konto durchgeführt werden.

So aktivieren Sie Application Signals für Ihre Anwendungen

Öffnen Sie die CloudWatch Konsole unter https://console.aws.amazon.com/cloudwatch/.
Wählen Sie im Navigationsbereich Services.
Wählen Sie Mit der Entdeckung Ihrer Services beginnen.
Aktivieren Sie das Kontrollkästchen und wählen Sie Start discovery your Services aus.

Wenn Sie diesen Schritt zum ersten Mal in Ihrem Konto ausführen, erstellt Application Signals die AWSServiceRoleForCloudWatchApplicationSignalsdienstbezogene Rolle. Diese Rolle gewährt Application Signals die folgenden Berechtigungen:
- xray:GetServiceGraph
- logs:StartQuery
- logs:GetQueryResults
- cloudwatch:GetMetricData
- cloudwatch:ListMetrics
- tag:GetResources
Weitere Informationen über diese Rolle finden Sie unter Dienstbezogene Rollenberechtigungen für CloudWatch Application Signals.

Schritt 2: Laden Sie den Agenten herunter und starten Sie ihn CloudWatch

Um den CloudWatch Agenten im Rahmen der Aktivierung von Application Signals auf einer EC2 Amazon-Instance oder einem lokalen Host zu installieren

Laden Sie die neueste Version des CloudWatch Agenten auf die Instance herunter. Wenn der CloudWatch Agent auf der Instanz bereits installiert ist, müssen Sie ihn möglicherweise aktualisieren. Nur Versionen des Agenten, die am 30. November 2023 oder später veröffentlicht wurden, unterstützen CloudWatch Application Signals.

Informationen zum Herunterladen des CloudWatch Agenten finden Sie unterLaden Sie das CloudWatch Agentenpaket herunter.
Bevor Sie den CloudWatch Agenten starten, konfigurieren Sie ihn so, dass er Application Signals aktiviert. Das folgende Beispiel zeigt eine CloudWatch Agentenkonfiguration, die Application Signals sowohl für Metriken als auch für Traces auf einem EC2 Host aktiviert.

Wir empfehlen, dass Sie diese Datei /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json auf Linux-Systemen unter speichern.
```
{
  "traces": {
    "traces_collected": {
      "application_signals": {}
    }
  },
  "logs": {
    "metrics_collected": {
      "application_signals": {}
    }
  }
}
```
Fügen Sie die CloudWatchAgentServerPolicyIAM-Richtlinie der IAM-Rolle Ihrer EC2 Amazon-Instance hinzu. Berechtigungen für lokale Hosts finden Sie unter. Berechtigungen für lokale Server
1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/
2. Wählen Sie Rollen und suchen Sie nach der Rolle, die von Ihrer EC2 Amazon-Instance verwendet wird. Wählen Sie dann den Namen dieser Rolle.
3. Wählen Sie auf der Registerkarte Berechtigungen die Option Berechtigungen hinzufügen und dann Richtlinien anfügen.
4. Finden Sie CloudWatchAgentServerPolicy. Verwenden Sie bei Bedarf das Suchfeld. Aktivieren Sie dann das Kontrollkästchen für die Richtlinie und wählen Sie dann Berechtigungen hinzufügen.
Starten Sie den CloudWatch Agenten, indem Sie die folgenden Befehle eingeben. agent-config-file-pathErsetzen Sie durch den Pfad zur CloudWatch Agentenkonfigurationsdatei, z. ./amazon-cloudwatch-agent.json B. Sie müssen das file:-Präfix wie abgebildet angeben.
```
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
```

Berechtigungen für lokale Server

Für einen lokalen Host müssen Sie Ihr Gerät AWS autorisieren.

Um Berechtigungen für einen lokalen Host einzurichten

Erstellen Sie den IAM-Benutzer, der verwendet werden soll, um Ihrem lokalen Host Berechtigungen zu erteilen:
1. Öffnen Sie unter https://console.aws.amazon.com/iam/ die IAM-Konsole.
2. Wählen Sie Benutzer, Benutzer erstellen aus.
3. Geben Sie unter Benutzerdetails für Benutzername einen Namen für den neuen IAM-Benutzer ein. Dies ist der Anmeldename AWS , der zur Authentifizierung Ihres Hosts verwendet wird. Wählen Sie anschließend Weiter.
4. Wählen Sie auf der Seite Berechtigungen festlegen unter Berechtigungsoptionen die Option Richtlinien direkt anhängen aus.
5. Wählen Sie aus der Liste der Berechtigungsrichtlinien die CloudWatchAgentServerPolicyRichtlinie aus, die Sie Ihrem Benutzer hinzufügen möchten. Wählen Sie anschließend Weiter.
6. Stellen Sie auf der Seite Überprüfen und erstellen sicher, dass Sie mit dem Benutzernamen zufrieden sind und dass die CloudWatchAgentServerPolicyRichtlinie in der Berechtigungsübersicht aufgeführt ist.
7. Wählen Sie „Benutzer erstellen“
Erstellen Sie Ihren AWS Zugangsschlüssel und Ihren geheimen Schlüssel und rufen Sie ihn ab:
1. Wählen Sie im Navigationsbereich der IAM-Konsole Benutzer und dann den Benutzernamen des Benutzers aus, den Sie im vorherigen Schritt erstellt haben.
2. Wählen Sie auf der Seite des Benutzers die Registerkarte Sicherheitsanmeldeinformationen aus. Wählen Sie dann im Abschnitt Zugriffsschlüssel die Option Zugriffsschlüssel erstellen aus.
3. Wählen Sie für Zugriffsschlüssel erstellen – Schritt 1 die Option Befehlszeilenschnittstelle (CLI) aus.
4. Geben Sie für Schritt 2 „Zugriffsschlüssel erstellen“ optional ein Tag ein und wählen Sie dann Weiter.
5. Wählen Sie für Schritt 3 „Zugriffsschlüssel erstellen“ die Option „.csv-Datei herunterladen“ aus, um eine .csv-Datei mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel Ihres IAM-Benutzers zu speichern. Sie benötigen diese Informationen für die nächsten Schritte.
6. Wählen Sie Erledigt aus.
Konfigurieren Sie Ihre AWS Anmeldeinformationen auf Ihrem lokalen Host, indem Sie den folgenden Befehl eingeben. Ersetzen Sie ACCESS_KEY_ID und SECRET_ACCESS_ID durch Ihren neu generierten Zugriffsschlüssel und Ihren geheimen Zugriffsschlüssel aus der CSV-Datei, die Sie im vorherigen Schritt heruntergeladen haben.
```
$ 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
```

Schritt 3: Ihre Anwendung instrumentieren und starten

Der nächste Schritt besteht darin, Ihre Anwendung für CloudWatch Application Signals zu instrumentieren.

Java

Um Ihre Java-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer EC2 Amazon-Instance oder einem lokalen Host zu instrumentieren

Laden Sie die neueste Version des Autoinstrumentation-Agenten von AWS Distro for OpenTelemetry Java herunter. Sie können die neueste Version über diesen Link herunterladen. Informationen zu allen veröffentlichten Versionen finden Sie unter aws-otel-java-instrumentation Releases.
Um die Vorteile von Application Signals zu optimieren, verwenden Sie Umgebungsvariablen, um zusätzliche Informationen bereitzustellen, bevor Sie Ihre Anwendung starten. Diese Informationen werden in den Dashboards von Application Signals angezeigt.
1. Geben Sie für die OTEL_RESOURCE_ATTRIBUTES-Variable die folgenden Informationen als Schlüssel-Wert-Paare an:
  - (Optional) service.name legt den Namen des Dienstes fest. Dieser wird in den Dashboards von Application Signals als Dienstname für Ihre Anwendung angezeigt. Wenn Sie keinen Wert für diesen Schlüssel angeben, wird der Standardwert von UnknownService verwendet.
  - (Optional) deployment.environment legt die Umgebung fest, in der die Anwendung ausgeführt wird. Dies wird in den Dashboards von Application Signals als Gehostet in-Umgebung Ihrer Anwendung angezeigt. Wenn Sie dies nicht angeben, wird einer der folgenden Standardwerte verwendet:
    Wenn es sich um eine Instance handelt, die Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf gesetzt ec2:name-of-Auto-Scaling-group
    Wenn es sich um eine EC2 Amazon-Instance handelt, die nicht Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf gesetzt ec2:default
    Wenn es sich um einen lokalen Host handelt, ist er auf eingestellt generic:default
    Diese Umgebungsvariable wird nur von Application Signals verwendet und in Röntgen-Trace-Anmerkungen und CloudWatch metrische Abmessungen umgewandelt.
  - Geben Sie für die OTEL_EXPORTER_OTLP_TRACES_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Traces exportiert werden sollen. Der CloudWatch Agent macht 4316 als seinen OTLP-Port verfügbar. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
  - Geben Sie für die OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Metriken exportiert werden sollen. Der CloudWatch Agent macht 4316 als seinen OTLP-Port verfügbar. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
  - Geben Sie für die JAVA_TOOL_OPTIONS Variable den Pfad an, in dem der Autoinstrumentation-Agent von AWS Distro for OpenTelemetry Java gespeichert ist.
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
```
    Zum Beispiel:
```
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH=./aws-opentelemetry-agent.jar
```
  - Für die OTEL_METRICS_EXPORTER-Variable empfehlen wir, den Wert auf none einzustellen. Dadurch werden andere Metrik-Exportprogramme deaktiviert, sodass nur der Application-Signals-Exporter verwendet wird.
  - Setzen Sie OTEL_AWS_APPLICATION_SIGNALS_ENABLED auf true. Dadurch werden Application-Signals-Metriken aus Traces generiert.

Starten Sie Ihre Anwendung mit den im vorherigen Schritt aufgeführten Umgebungsvariablen. Im Folgenden finden Sie ein Beispiel für ein Start-Skript.

Anmerkung

Die folgende Konfiguration unterstützt nur Versionen 1.32.2 und höher des Agenten AWS Distro for OpenTelemetry Auto-Instrumentation für Java.


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="service.name=$YOUR_SVC_NAME" \
java -jar $MY_JAVA_APP.jar

(Optional) Um die Protokollkorrelation zu aktivierenOTEL_RESOURCE_ATTRIBUTES, legen Sie in eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Traces und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie diese Variable $YOUR_APPLICATION_LOG_GROUP durch die Namen der Protokollgruppen für Ihre Anwendung. Wenn Sie mehrere Protokollgruppen haben, können Sie sie mit einem Und-Zeichen (&) trennen, wie in diesem Beispiel:. aws.log.group.names=log-group-1&log-group-2 Um die Korrelation zwischen Metrik und Protokoll zu aktivieren, reicht es aus, diese aktuelle Umgebungsvariable festzulegen. Weitere Informationen finden Sie unter Metrik aktivieren, um Korrelation zu protokollieren. Um die Korrelation zwischen Trace und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Aktivieren Sie die Korrelation zwischen Trace und Protokoll.

Im Folgenden finden Sie ein Beispiel für ein Startskript, das dabei hilft, die Protokollkorrelation zu aktivieren.
```
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

Anmerkung

Wenn Sie einen WSGI-Server für Ihre Python-Anwendung verwenden, finden Sie zusätzlich zu den folgenden Schritten in diesem Abschnitt Informationen Keine Anwendungssignaldaten für eine Python-Anwendung, die einen WSGI-Server verwendet zum Funktionieren von Anwendungssignalen unter.

Um Ihre Python-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer EC2 Amazon-Instance zu instrumentieren

Laden Sie die neueste Version des Agenten für die automatische Instrumentierung von AWS Distro for OpenTelemetry Python herunter. Für die Installation führen Sie den folgenden -Befehl aus.
```
pip install aws-opentelemetry-distro
```
Sie können Informationen zu allen veröffentlichten Versionen unter AWS Distro for OpenTelemetry Python Instrumentation einsehen.
Um die Vorteile von Application Signals zu optimieren, verwenden Sie Umgebungsvariablen, um zusätzliche Informationen bereitzustellen, bevor Sie Ihre Anwendung starten. Diese Informationen werden in den Dashboards von Application Signals angezeigt.
1. Geben Sie für die OTEL_RESOURCE_ATTRIBUTES-Variable die folgenden Informationen als Schlüssel-Wert-Paare an:
  - service.name legt den Namen des Services fest. Dies wird in den Dashboards von Application Signals als Servicename der Anwendung angezeigt. Wenn Sie keinen Wert für diesen Schlüssel angeben, wird der Standardwert von UnknownService verwendet.
  - deployment.environment legt die Umgebung fest, in der die Anwendung ausgeführt wird. Dies wird in den Dashboards von Application Signals als Gehostet in-Umgebung Ihrer Anwendung angezeigt. Wenn Sie dies nicht angeben, wird einer der folgenden Standardwerte verwendet:
    Wenn es sich um eine Instance handelt, die Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf eingestelltec2:name-of-Auto-Scaling-group.
    Wenn es sich um eine EC2 Amazon-Instance handelt, die nicht Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf gesetzt ec2:default
    Wenn es sich um einen lokalen Host handelt, ist er auf eingestellt generic:default
    Dieser Attributschlüssel wird nur von Application Signals verwendet und in Röntgen-Trace-Anmerkungen und CloudWatch metrische Dimensionen umgewandelt.
2. Geben Sie für die OTEL_EXPORTER_OTLP_PROTOCOL Variable http/protobuf an, dass Telemetriedaten über HTTP an die in den folgenden Schritten aufgeführten CloudWatch Agenten-Endpunkte exportiert werden sollen.
3. Geben Sie für die OTEL_EXPORTER_OTLP_TRACES_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Traces exportiert werden sollen. Der CloudWatch Agent stellt 4316 als seinen OTLP-Port über HTTP zur Verfügung. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Geben Sie für die OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Metriken exportiert werden sollen. Der CloudWatch Agent stellt 4316 als seinen OTLP-Port über HTTP zur Verfügung. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Für die OTEL_METRICS_EXPORTER-Variable empfehlen wir, den Wert auf none einzustellen. Dadurch werden andere Metrik-Exportprogramme deaktiviert, sodass nur der Application-Signals-Exporter verwendet wird.
6. Setzen Sie die OTEL_AWS_APPLICATION_SIGNALS_ENABLED Variable auf, true damit Ihr Container beginnt, X-Ray-Traces und CloudWatch -Metriken an Application Signals zu senden.
Starten Sie Ihre Anwendung mit den Umgebungsvariablen, die im vorherigen Schritt beschrieben wurden. Im Folgenden finden Sie ein Beispiel für ein Start-Skript.
- Ersetzen Sie $SVC_NAME mit dem Namen Ihrer Anwendung. Dies wird in den Dashboards von Application Signals als Name der Anwendung angezeigt.
- $PYTHON_APPErsetzen Sie es durch den Speicherort und den Namen Ihrer Anwendung.
```
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
```
Bevor Sie Application Signals für Ihre Python-Anwendungen aktivieren, sollten Sie die folgenden Überlegungen beachten.
- In einigen containerisierten Anwendungen kann eine fehlende PYTHONPATH Umgebungsvariable manchmal dazu führen, dass die Anwendung nicht gestartet werden kann. Um dieses Problem zu beheben, stellen Sie sicher, dass Sie die PYTHONPATH Umgebungsvariable auf den Speicherort des Arbeitsverzeichnisses Ihrer Anwendung setzen. Dies ist auf ein bekanntes Problem mit der OpenTelemetry automatischen Instrumentierung zurückzuführen. Weitere Informationen zu diesem Problem finden Sie unter Die Python-Autoinstrumentation-Einstellung von PYTHONPATH ist nicht kompatibel.
- Für Django-Anwendungen sind zusätzliche Konfigurationen erforderlich, die in der OpenTelemetry Python-Dokumentation beschrieben werden.
  - Verwenden Sie das --noreload Flag, um ein automatisches Neuladen zu verhindern.
  - Setzen Sie die DJANGO_SETTINGS_MODULE Umgebungsvariable auf den Speicherort der Datei Ihrer Django-Anwendung. settings.py Dadurch wird sichergestellt, dass OpenTelemetry Sie korrekt auf Ihre Django-Einstellungen zugreifen und diese integrieren können.
(Optional) Um die Protokollkorrelation zu aktivierenOTEL_RESOURCE_ATTRIBUTES, legen Sie in eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Traces und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie diese Variable $YOUR_APPLICATION_LOG_GROUP durch die Namen der Protokollgruppen für Ihre Anwendung. Wenn Sie mehrere Protokollgruppen haben, können Sie sie mit einem Und-Zeichen (&) trennen, wie in diesem Beispiel:. aws.log.group.names=log-group-1&log-group-2 Um die Korrelation zwischen Metrik und Protokoll zu aktivieren, reicht es aus, diese aktuelle Umgebungsvariable festzulegen. Weitere Informationen finden Sie unter Metrik aktivieren, um Korrelation zu protokollieren. Um die Korrelation zwischen Trace und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Aktivieren Sie die Korrelation zwischen Trace und Protokoll.

Im Folgenden finden Sie ein Beispiel für ein Startskript, das dabei hilft, die Protokollkorrelation zu aktivieren.
```
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

Um Ihre .NET-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer EC2 Amazon-Instance oder einem lokalen Host zu instrumentieren

Laden Sie die neueste Version des AWS Autoinstrumentationspakets Distro for OpenTelemetry .NET herunter. Sie können die neueste Version unter aws-otel-dotnet-instrumentation Releases herunterladen.

Um Application Signals zu aktivieren, legen Sie die folgenden Umgebungsvariablen fest, um zusätzliche Informationen bereitzustellen, bevor Sie Ihre Anwendung starten. Diese Variablen sind erforderlich, um den Startup-Hook für die .NET-Instrumentierung einzurichten, bevor Sie Ihre .NET-Anwendung starten.

Im Folgenden finden Sie ein Beispiel für 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=aws-otel-integ-test
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

Das Folgende ist ein Beispiel für 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=aws-otel-integ-test"
$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"

Starten Sie Ihre Anwendung mit den im vorherigen Schritt aufgeführten Umgebungsvariablen.

(Optional) Alternativ können Sie die bereitgestellten Installationsskripten verwenden, um die Installation und Einrichtung des AWS Autoinstrumentationspakets Distro for OpenTelemetry .NET zu unterstützen.

Laden Sie für Linux das Bash-Installationsskript von der Releases-Seite herunter und installieren Sie es: 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

Laden Sie für Windows Server das PowerShell Installationsskript von der GitHub Releases-Seite herunter und installieren Sie es:


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

Sie finden das NuGet Paket des Autoinstrumentationspakets AWS Distro for OpenTelemetry .NET im offiziellen NuGet Repository. Anweisungen finden Sie in der README-Datei.

Node.js

Anmerkung

Wenn Sie Application Signals für eine Node.js -Anwendung mit ESM aktivieren, sollten Sie sich informieren, Setting up a Node.js application with the ESM module format bevor Sie mit diesen Schritten beginnen.

Um Ihre Node.js -Anwendungen als Teil der Aktivierung von Application Signals auf einer EC2 Amazon-Instance zu instrumentieren

Laden Sie die neueste Version des Agenten AWS Distro for OpenTelemetry JavaScript Auto-Instrumentation für Node.js herunter. Für die Installation führen Sie den folgenden -Befehl aus.
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
Sie können Informationen zu allen veröffentlichten Versionen bei AWS Distro for Instrumentation einsehen. OpenTelemetry JavaScript
Um die Vorteile von Application Signals zu optimieren, verwenden Sie Umgebungsvariablen, um zusätzliche Informationen bereitzustellen, bevor Sie Ihre Anwendung starten. Diese Informationen werden in den Dashboards von Application Signals angezeigt.
1. Geben Sie für die OTEL_RESOURCE_ATTRIBUTES-Variable die folgenden Informationen als Schlüssel-Wert-Paare an:
  - service.name legt den Namen des Services fest. Dies wird in den Dashboards von Application Signals als Servicename der Anwendung angezeigt. Wenn Sie keinen Wert für diesen Schlüssel angeben, wird der Standardwert von UnknownService verwendet.
  - deployment.environment legt die Umgebung fest, in der die Anwendung ausgeführt wird. Dies wird in den Dashboards von Application Signals als Gehostet in-Umgebung Ihrer Anwendung angezeigt. Wenn Sie dies nicht angeben, wird einer der folgenden Standardwerte verwendet:
    Wenn es sich um eine Instance handelt, die Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf eingestelltec2:name-of-Auto-Scaling-group.
    Wenn es sich um eine EC2 Amazon-Instance handelt, die nicht Teil einer Auto Scaling Scaling-Gruppe ist, ist sie auf gesetzt ec2:default
    Wenn es sich um einen lokalen Host handelt, ist er auf eingestellt generic:default
    Dieser Attributschlüssel wird nur von Application Signals verwendet und in Röntgen-Trace-Anmerkungen und CloudWatch metrische Dimensionen umgewandelt.
2. Geben Sie für die OTEL_EXPORTER_OTLP_PROTOCOL Variable http/protobuf an, dass Telemetriedaten über HTTP an die in den folgenden Schritten aufgeführten CloudWatch Agenten-Endpunkte exportiert werden sollen.
3. Geben Sie für die OTEL_EXPORTER_OTLP_TRACES_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Traces exportiert werden sollen. Der CloudWatch Agent stellt 4316 als seinen OTLP-Port über HTTP zur Verfügung. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Geben Sie für die OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT-Variable die Basis-Endpunkt-URL an, in die die Metriken exportiert werden sollen. Der CloudWatch Agent stellt 4316 als seinen OTLP-Port über HTTP zur Verfügung. Da Anwendungen bei Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf setzen OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Für die OTEL_METRICS_EXPORTER-Variable empfehlen wir, den Wert auf none einzustellen. Dadurch werden andere Metrik-Exportprogramme deaktiviert, sodass nur der Application-Signals-Exporter verwendet wird.
6. Setzen Sie die OTEL_AWS_APPLICATION_SIGNALS_ENABLED Variable auf, true damit Ihr Container beginnt, X-Ray-Traces und CloudWatch -Metriken an Application Signals zu senden.

Starten Sie Ihre Anwendung mit den Umgebungsvariablen, die im vorherigen Schritt beschrieben wurden. Im Folgenden finden Sie ein Beispiel für ein Start-Skript.

Ersetzen Sie $SVC_NAME mit dem Namen Ihrer Anwendung. Dies wird in den Dashboards von Application Signals als Name der Anwendung angezeigt.


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

(Optional) Um die Protokollkorrelation zu aktivierenOTEL_RESOURCE_ATTRIBUTES, legen Sie in eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Traces und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie diese Variable $YOUR_APPLICATION_LOG_GROUP durch die Namen der Protokollgruppen für Ihre Anwendung. Wenn Sie mehrere Protokollgruppen haben, können Sie sie mit einem Und-Zeichen (&) trennen, wie in diesem Beispiel:. aws.log.group.names=log-group-1&log-group-2 Um die Korrelation zwischen Metrik und Protokoll zu aktivieren, reicht es aus, diese aktuelle Umgebungsvariable festzulegen. Weitere Informationen finden Sie unter Metrik aktivieren, um Korrelation zu protokollieren. Um die Korrelation zwischen Trace und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Aktivieren Sie die Korrelation zwischen Trace und Protokoll.

Im Folgenden finden Sie ein Beispiel für ein Startskript, das dabei hilft, die Protokollkorrelation zu aktivieren.
```
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
```

Einrichtung einer Anwendung Node.js mit dem ESM-Modulformat

Wir bieten eingeschränkte Unterstützung für Node.js -Anwendungen im ESM-Modulformat. Details hierzu finden Sie unter Bekannte Einschränkungen von Node.js mit ESM.

Um Application Signals für eine Node.js -Anwendung mit ESM zu aktivieren, müssen Sie die Schritte im vorherigen Verfahren ändern.

Installieren Sie zunächst @opentelemetry/instrumentation für Ihre Anwendung Node.js:


npm install @opentelemetry/instrumentation@0.54.0

Ändern Sie dann in den Schritten 3 und 4 des vorherigen Verfahrens die Knotenoptionen von:


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

in den folgenden Wert:


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Bereitstellen mit dem AWS Cloud Development Kit (AWS CDK)

Aktivieren Sie Anwendungssignale auf Kubernetes-Plattformen