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 auf Amazon EC2

Aktivieren Sie CloudWatch Application Signals auf Amazon, EC2 indem Sie die in diesem Abschnitt beschriebenen benutzerdefinierten Einrichtungsschritte verwenden.

Für Anwendungen, die auf Amazon ausgeführt werden EC2, 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 gelten für 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, Unterstützte Systeme bevor Sie Application Signals aktivieren.

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 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.
Bevor Sie den CloudWatch Agenten starten, konfigurieren Sie ihn so, dass Application Signals aktiviert wird. 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 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": {}
    }
  }
}
```
Fügen Sie die CloudWatchAgentServerPolicyIAM-Richtlinie der IAM-Rolle Ihrer EC2 Amazon-Instance hinzu. 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 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 On-Premises-Server

Bei einem 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 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 aus.
Erstellen Sie Ihren AWS Zugriffsschlü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 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 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 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 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 On-Premises-Host handelt, ist er festgelegt auf 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 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 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_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 WSGI-Server für Ihre Python-Anwendung verwenden, finden Sie zusätzlich zu den folgenden Schritten in diesem Abschnitt Informationen zur Verwendung von Application Signals unter Keine Application-Signals-Daten für eine Python-Anwendung, die einen WSGI-Server verwendet.

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 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 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 On-Premises-Host handelt, ist er festgelegt auf 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.
- 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 werden.
  - Verwenden Sie das --noreload-Flag, um ein automatisches Neuladen zu verhindern.
  - Legen Sie die DJANGO_SETTINGS_MODULE-Umgebungsvariable für den Speicherort der settings.py-Datei Ihrer Django-Anwendung fest. 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

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. 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 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"
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 Application Signals für eine Node.js-Anwendung mit ESM aktivieren, sollten Sie sich unter Setting up a Node.js application with the ESM module format informieren, 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 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 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 On-Premises-Host handelt, ist er festgelegt auf 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 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
```

Einrichtung einer Node.js-Anwendung 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 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 EC2 Amazon-Instances durch dialogorientierte KI-Interaktionen zu aktivieren. Dies bietet eine Benutzeroberfläche in natürlicher Sprache für die Einrichtung der Überwachung von Application Signals.

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

Voraussetzungen

Bevor Sie den MCP-Server zur Aktivierung von Application Signals 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 anderen MCP-kompatiblen Tools)
Der in Ihrer IDE CloudWatch konfigurierte MCP-Server von Application Signals. Detaillierte Anweisungen zur Einrichtung finden Sie in der Dokumentation zum CloudWatch Application Signals MCP Server.

Verwenden des MCP-Servers

Sobald 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 Programmierassistent kann zwar den Kontext aus Ihrer Projektstruktur ableiten, die Angabe spezifischer Details in Ihren Eingabeaufforderungen trägt jedoch zu einer genaueren und relevanteren Anleitung bei. Geben Sie Informationen wie Ihre Anwendungssprache, Instanzdetails und absolute Pfade zu Ihrer Infrastruktur und Ihrem Anwendungscode an.

Aufforderungen zu bewährten Methoden (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 MCP-Servers von CloudWatch Application Signals bietet mehrere Vorteile:

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

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

Sobald Sie Ihre Anwendungen bei Amazon aktiviert haben EC2, können Sie den Zustand Ihrer Anwendungen ü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