Schritt 1: Application Signals in Ihrem Konto aktivieren Schritt 2: Laden Sie den CloudWatch Agenten herunter und starten Sie ihn Schritt 3: Ihre Anwendung instrumentieren und starten Aktivieren Sie Anwendungssignale auf Amazon EC2 mithilfe des Model Context Protocol (MCP)(Optional) Überwachen Sie den Zustand Ihrer Anwendung

Aktivieren Sie Ihre Anwendungen in Amazon EC2

Aktivieren Sie CloudWatch Anwendungssignale auf Amazon EC2 mithilfe der in diesem Abschnitt beschriebenen benutzerdefinierten Einrichtungsschritte.

Für Anwendungen, die auf Amazon EC2 ausgeführt werden, installieren und konfigurieren Sie den CloudWatch Agenten und die AWS Distribution selbst. OpenTelemetry 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 gelten für Java-, Python- und .NET-Anwendungen. Die Schritte wurden auf Amazon EC2-Instances getestet, es wird jedoch erwartet, dass sie auch auf anderen Architekturen funktionieren, für die Distro unterstützt wird. AWS OpenTelemetry

Voraussetzungen

Um Unterstützung für Application Signals zu erhalten, müssen Sie die neueste Version sowohl des Agenten als auch der CloudWatch Distribution for Agent verwenden. AWS OpenTelemetry
Sie müssen das auf der AWS CLI Instance 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 es bereits OpenTelemetry mit einer Anwendung verwenden, die Sie für Anwendungssignale aktivieren möchten, lesen Sie Unterstützte Systeme vor der Aktivierung von Anwendungssignalen nach.

Schritt 1: Application Signals in Ihrem Konto aktivieren

Sie müssen Application Signals zuerst in Ihrem Konto aktivieren. Wenn Sie dies nicht getan haben, siehe Application Signals in Ihrem Konto aktivieren.

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

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

Laden Sie die neueste Version des CloudWatch Agenten auf die Instance herunter. Wenn auf der Instanz der CloudWatch Agent 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 Anwendungssignale.
Bevor Sie den CloudWatch Agenten starten, konfigurieren Sie ihn für die Aktivierung von Anwendungssignalen. Das folgende Beispiel ist eine CloudWatch Agentenkonfiguration, die Anwendungssignale sowohl für Metriken als auch für Traces auf einem EC2-Host aktiviert.

Wir empfehlen, dass Sie diese Datei auf Linux-Systemen unter /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json speichern.
```
{
  "traces": {
    "traces_collected": {
      "application_signals": {}
    }
  },
  "logs": {
    "metrics_collected": {
      "application_signals": {}
    }
  }
}
```
Hängen Sie die CloudWatchAgentServerPolicy IAM-Richtlinie an die IAM-Rolle Ihrer Amazon EC2-Instance an. Informationen zu Berechtigungen für On-Premises-Hosts finden Sie unter Berechtigungen für On-Premises-Server.
1. Melden Sie sich bei der an AWS-Managementkonsole 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 Amazon-EC2-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 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 On-Premises-Server

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

So richten Sie Berechtigungen für einen On-Premises–Host ein

Erstellen Sie den IAM-Benutzer, der verwendet werden soll, um Ihrem On-Premises-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 für Berechtigungsoptionen die Option Direktes Anfügen von Richtlinien aus.
5. Wählen Sie aus der Liste der Berechtigungsrichtlinien die CloudWatchAgentServerPolicy Richtlinie aus, die Sie Ihrem Benutzer hinzufügen möchten. Klicken Sie anschließend auf Weiter.
6. Vergewissern Sie sich auf der Seite „Überprüfen und erstellen“, dass Sie mit dem Benutzernamen zufrieden sind und dass die CloudWatchAgentServerPolicy Richtlinie in der Übersicht der Berechtigungen aufgeführt ist.
7. Wählen Sie Benutzer erstellen aus.
Erstellen Sie Ihren AWS Zugriffsschlüssel und Ihren geheimen Schlüssel und rufen Sie sie ab:
1. Wählen Sie im Navigationsbereich der IAM-Konsole Benutzer und dann den Benutzernamen des Benutzers aus, den Sie zuvor erstellt haben.
2. Wählen Sie auf der Seite des Benutzers die Registerkarte Sicherheits-Anmeldeinformationen aus. Wählen Sie im Abschnitt Zugriffsschlüssel 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 Zugriffsschlüssel erstellen – Schritt 2 ein optionales Tag ein und wählen Sie Weiter aus.
5. Wählen Sie unter Zugriffsschlüssel erstellen – Schritt 3 die Option CSV-Datei herunterladen aus, um eine CSV-Datei mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel Ihres IAM-Benutzers zu speichern. Diese Informationen sind für die nächsten Schritte erforderlich.
6. Wählen Sie Fertig 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 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 Anwendungssignale zu instrumentieren.

Java

So instrumentieren Sie Ihre Java-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer Amazon-EC2-Instance oder auf einem On-Premises-Host

Laden Sie die neueste Version des AWS Distro for OpenTelemetry Java Autoinstrumentation-Agenten herunter. Sie können die neueste Version über diesen Link herunterladen. Informationen zu allen veröffentlichten Versionen finden Sie unter aws-otel-java-instrumentation-Versionen.
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 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.
  - (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 das eine Instance ist, die Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:name-of-Auto-Scaling-group
    Wenn dies eine Amazon-EC2-Instance ist, die nicht Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:default
    Wenn es sich um einen On-Premises-Host handelt, ist er festgelegt auf generic:default
    Diese Umgebungsvariable wird nur von Application Signals verwendet und in X-Ray Trace-Anmerkungen und CloudWatch metrische Dimensionen 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 OTLP-Port verfügbar. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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 OTLP-Port verfügbar. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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 AWS Distro for OpenTelemetry Java Autoinstrumentation-Agent gespeichert ist.
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
```
    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 Umgebungsvariablen, die im vorherigen Schritt aufgelistet wurden. Im Folgenden finden Sie ein Beispiel für ein Start-Skript.

Anmerkung

Die folgende Konfiguration unterstützt nur die Versionen 1.32.2 und höher des AWS Distro for OpenTelemetry Auto-Instrumentation Agents für 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

(Optional) Um die Protokollkorrelation zu aktivieren, legen Sie in OTEL_RESOURCE_ATTRIBUTES eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Ablaufverfolgungen und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie für 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 zur Protokollierungskorrelation aktivieren. Um die Korrelation zwischen Ablaufverfolgung und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Die Korrelation von Ablaufverfolgung zu Protokollen aktivieren.

Im Folgenden finden Sie ein Beispiel für ein Startskript, das die Protokollkorrelation aktiviert.
```
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 Pre-Fork-Server (WSGI oder ASGI) wie Gunicorn, uWSGI oder Uvicorn für Ihre Python-Anwendung verwenden, finden Sie zusätzlich zu den folgenden Schritten in diesem Abschnitt Informationen zur Funktionsweise von Application Signals unter. Keine Anwendungssignaldaten für eine Python-Anwendung, die einen Pre-Fork-Server (WSGI oder ASGI) verwendet

So instrumentieren Sie Ihre Python-Anwendungen im Rahmen der Aktivierung von Application Signalen auf einer Amazon-EC2-Instance

Laden Sie die neueste Version des Distro for Python Autoinstrumentation-Agenten herunter. AWS OpenTelemetry Für die Installation führen Sie den folgenden -Befehl aus.
```
pip install aws-opentelemetry-distro
```
Informationen zu allen veröffentlichten Versionen finden Sie unter AWS Distro for OpenTelemetry Python Instrumentation.
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 das nicht angeben, wird einer der folgenden Standardwerte verwendet:
    Wenn dies eine Instance ist, die Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:name-of-Auto-Scaling-group.
    Wenn dies eine Amazon-EC2-Instance ist, die nicht Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:default
    Wenn es sich um einen On-Premises-Host handelt, ist er festgelegt auf generic:default
    Dieser Attributschlüssel wird nur von Application Signals verwendet und in X-Ray 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 macht 4316 als OTLP-Port über HTTP verfügbar. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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 mit dem Senden von X-Ray Traces und CloudWatch Metriken an Application Signals beginnt.
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.
- Ersetzen Sie $PYTHON_APP mit dem Speicherort und 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
```
Berücksichtigen Sie die folgenden Überlegungen, bevor Sie Application Signals für Ihre Python-Anwendungen aktivieren.
- 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 Python-Autoinstrumentierungs-Einstellung von PYTHONPATH ist nicht kompatibel.
- Für Django-Anwendungen sind zusätzliche Konfigurationen erforderlich, die in der OpenTelemetry Python-Dokumentation beschrieben sind.
  - 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 aktivieren, legen Sie in OTEL_RESOURCE_ATTRIBUTES eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Ablaufverfolgungen und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie für 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 zur Protokollierungskorrelation aktivieren. Um die Korrelation zwischen Ablaufverfolgung und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Die Korrelation von Ablaufverfolgung zu Protokollen aktivieren.

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

So instrumentieren Sie Ihre .NET-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer Amazon-EC2-Instance oder auf einem On-Premises-Host

Laden Sie die neueste Version des AWS Distro for OpenTelemetry .NET-Autoinstrumentationspakets herunter. Sie können die neueste Version unter aws-otel-dotnet-instrumentation-Versionen 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. Ersetzen Sie dotnet-service-name in der OTEL_RESOURCE_ATTRIBUTES-Umgebungsvariable durch den Servicenamen Ihrer Wahl.

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

Es folgt 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=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"

Starten Sie Ihre Anwendung mit den Umgebungsvariablen, die im vorherigen Schritt aufgelistet wurden.

(Optional) Alternativ können Sie die mitgelieferten Installationsskripts verwenden, um die Installation und Einrichtung des AWS Distro for OpenTelemetry .NET-Autoinstrumentation-Pakets 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 Release-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"
Register-OpenTelemetryForIIS

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 Anwendungssignale für eine Node.js Anwendung mit ESM aktivieren, lesen Sie diese Schritte, Setting up a Node.js application with the ESM module format bevor Sie beginnen.

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

Laden Sie die neueste Version des Agenten AWS Distro for OpenTelemetry JavaScript Auto Instrumentation für herunter. Node.js Für die Installation führen Sie den folgenden -Befehl aus.
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
Informationen zu allen veröffentlichten Versionen finden Sie unter AWS Distro for Instrumentation. 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 das nicht angeben, wird einer der folgenden Standardwerte verwendet:
    Wenn dies eine Instance ist, die Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:name-of-Auto-Scaling-group.
    Wenn dies eine Amazon-EC2-Instance ist, die nicht Teil einer Auto-Scaling-Gruppe ist, ist sie festgelegt auf ec2:default
    Wenn es sich um einen On-Premises-Host handelt, ist er festgelegt auf generic:default
    Dieser Attributschlüssel wird nur von Application Signals verwendet und in X-Ray 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 macht 4316 als OTLP-Port über HTTP verfügbar. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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. In Amazon EC2 sollten Sie diesen Wert auf setzen, da Anwendungen mit dem lokalen CloudWatch Agenten kommunizieren 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 mit dem Senden von X-Ray Traces und CloudWatch Metriken an Application Signals beginnt.

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 aktivieren, legen Sie in OTEL_RESOURCE_ATTRIBUTES eine zusätzliche Umgebungsvariable aws.log.group.names für die Protokollgruppen Ihrer Anwendung fest. Auf diese Weise können die Ablaufverfolgungen und Metriken aus Ihrer Anwendung mit den relevanten Protokolleinträgen aus diesen Protokollgruppen korreliert werden. Ersetzen Sie für 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 zur Protokollierungskorrelation aktivieren. Um die Korrelation zwischen Ablaufverfolgung und Protokoll zu aktivieren, müssen Sie auch die Protokollierungskonfiguration in Ihrer Anwendung ändern. Weitere Informationen finden Sie unter Die Korrelation von Ablaufverfolgung zu Protokollen aktivieren.

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

Eine Node.js Anwendung mit dem ESM-Modulformat einrichten

Wir bieten eingeschränkten Support für Node.js Anwendungen mit dem ESM-Modulformat. Details hierzu finden Sie unter Bekannte Einschränkungen Node.js bei ESM.

Um Anwendungssignale 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 Node.js Anwendung:


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 Folgendes:


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

Aktivieren Sie Anwendungssignale auf Amazon EC2 mithilfe des Model Context Protocol (MCP)

Sie können den MCP-Server ( CloudWatch Application Signals Model Context Protocol) verwenden, um Application Signals auf Ihren Amazon EC2-Instances durch dialogorientierte KI-Interaktionen zu aktivieren. Dies bietet eine Oberfläche in natürlicher Sprache für die Einrichtung der Überwachung von Anwendungssignalen.

Der MCP-Server automatisiert den Aktivierungsprozess, indem er Ihre Anforderungen versteht und die entsprechende Konfiguration generiert. Anstatt die Einrichtungsschritte manuell zu befolgen, können Sie einfach beschreiben, was Sie aktivieren möchten.

Voraussetzungen

Bevor Sie den MCP-Server zur Aktivierung von Anwendungssignalen verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:

Eine Entwicklungsumgebung, die MCP unterstützt (wie Kiro, Claude Desktop, VSCode mit MCP-Erweiterungen oder andere Tools) MCP-compatible
Der in Ihrer CloudWatch IDE konfigurierte MCP-Server von Application Signals. Eine ausführliche Anleitung zur Einrichtung finden Sie in der Dokumentation zum CloudWatch Application Signals MCP Server.

Verwenden des MCP-Servers

Nachdem Sie den CloudWatch Application Signals MCP-Server in Ihrer IDE konfiguriert haben, können Sie mithilfe von Eingabeaufforderungen in natürlicher Sprache Anleitungen zur Aktivierung anfordern. Der Coding-Assistent kann zwar den Kontext aus Ihrer Projektstruktur ableiten, aber wenn Sie in Ihren Eingabeaufforderungen spezifische Details angeben, können Sie eine genauere und relevantere Anleitung gewährleisten. Fügen Sie Informationen wie Ihre Anwendungssprache, Instanzdetails und absolute Pfade zu Ihrer Infrastruktur und Ihrem Anwendungscode hinzu.

Aufforderungen zu bewährten Verfahren (spezifisch und vollständig):


"Enable Application Signals for my Python service running on EC2.
My app code is in /home/ec2-user/flask-api and IaC is in /home/ec2-user/flask-api/terraform"

"I want to add observability to my Java application on EC2.
The application code is at /opt/apps/checkout-service and
the infrastructure code is at /opt/apps/checkout-service/cloudformation"

"Help me instrument my Node.js application on EC2 with Application Signals.
Application directory: /home/ubuntu/payment-api
Terraform code: /home/ubuntu/payment-api/terraform"

Weniger effektive Aufforderungen:


"Enable monitoring for my app"
→ Missing: platform, language, paths

"Enable Application Signals. My code is in ./src and IaC is in ./infrastructure"
→ Problem: Relative paths instead of absolute paths

"Enable Application Signals for my EC2 service at /home/user/myapp"
→ Missing: programming language

Schnelle Vorlage:


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

Vorteile der Verwendung des MCP-Servers

Die Verwendung des CloudWatch Application Signals MCP-Servers bietet mehrere Vorteile:

Oberfläche in natürlicher Sprache: Beschreiben Sie, was Sie aktivieren möchten, ohne sich Befehle oder die Konfigurationssyntax merken zu müssen
Context-aware Anleitung: Der MCP-Server versteht Ihre spezifische Umgebung und gibt maßgeschneiderte Empfehlungen
Weniger Fehler: Die automatische Generierung der Konfiguration minimiert manuelle Tippfehler
Schnellere Einrichtung: Kommen Sie schneller von der Absicht zur Implementierung
Lerntool: Sehen Sie sich die generierten Konfigurationen an und erfahren Sie, wie Application Signals funktioniert

Weitere Ressourcen

Weitere Informationen zur Konfiguration und Verwendung des CloudWatch Application Signals MCP-Servers finden Sie in der MCP-Serverdokumentation.

(Optional) Überwachen Sie den Zustand Ihrer Anwendung

Nachdem Sie Ihre Anwendungen auf Amazon EC2 aktiviert haben, können Sie den Zustand Ihrer Anwendung überwachen. Weitere Informationen finden Sie unter Den Betriebsstatus Ihrer Anwendungen mit Application Signals überwachen.

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

Anwendungen auf Amazon-EKS-Clustern aktivieren

Aktivieren Sie Ihre Anwendungen auf Amazon ECS