Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Aktivieren Sie Ihre Anwendungen in 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 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 EC2-Instances getestet, es wird jedoch erwartet, dass sie auch auf anderen Architekturen funktionieren, für die AWS Distro unterstützt wird. OpenTelemetry
**Voraussetzungen**
+ Um Support 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 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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). 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](CloudWatch-Application-Signals-supportmatrix.md) 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](CloudWatch-Application-Signals-Enable.md).
## 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 EC2-Instance oder einem lokalen Host zu installieren**
1. 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.
1. 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": {}
}
}
}
```
1. Fügen Sie die **CloudWatchAgentServerPolicy**IAM-Richtlinie der IAM-Rolle Ihrer Amazon EC2 EC2-Instance hinzu. Informationen zu Berechtigungen für On-Premises-Hosts finden Sie unter [Berechtigungen für On-Premises-Server](#Enable-OnPremise-Permissions).
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. 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.
1. Wählen Sie auf der Registerkarte **Berechtigungen** die Option **Berechtigungen hinzufügen** und dann **Richtlinien anfügen**.
1. 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**.
1. Starten Sie den CloudWatch Agenten, indem Sie die folgenden Befehle eingeben. {{agent-config-file-path}}Ersetzen 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**
1. 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/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie **Benutzer**, **Benutzer erstellen** aus.
1. 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**.
1. Wählen Sie auf der Seite **Berechtigungen festlegen** für **Berechtigungsoptionen** die Option **Direktes Anfügen von Richtlinien** aus.
1. 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**.
1. Stellen Sie auf der Seite **Überprüfen und erstellen** sicher, dass Sie mit dem Benutzernamen zufrieden sind und dass die **CloudWatchAgentServerPolicy**Richtlinie in der **Berechtigungsübersicht aufgeführt** ist.
1. Wählen Sie **Benutzer erstellen** aus.
1. 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.
1. Wählen Sie auf der Seite des Benutzers die Registerkarte **Sicherheits-Anmeldeinformationen** aus. Wählen Sie im Abschnitt **Zugriffsschlüssel** **Zugriffsschlüssel erstellen** aus.
1. Wählen Sie für **Zugriffsschlüssel erstellen – Schritt 1** die Option **Befehlszeilenschnittstelle (CLI)** aus.
1. Geben Sie für **Zugriffsschlüssel erstellen – Schritt 2** ein optionales Tag ein und wählen Sie **Weiter** aus.
1. 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.
1. Wählen Sie **Fertig** aus.
1. 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 ]
**So instrumentieren Sie Ihre Java-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer Amazon-EC2-Instance oder auf einem On-Premises-Host**
1. Laden Sie die neueste Version des Autoinstrumentation-Agenten von AWS Distro for OpenTelemetry Java herunter. Sie können die neueste Version über [diesen Link](https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/aws-opentelemetry-agent.jar) herunterladen. [Informationen zu allen veröffentlichten Versionen finden Sie unter aws-otel-java-instrumentation Releases.](https://github.com/aws-observability/aws-otel-java-instrumentation/releases)
1. 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 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 in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `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 gibt 4316 als seinen OTLP-Port an. Da Anwendungen in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `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}}"
```
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.
1. 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
```
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
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](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-Python-WSGI).
**So instrumentieren Sie Ihre Python-Anwendungen im Rahmen der Aktivierung von Application Signalen auf einer Amazon-EC2-Instance**
1. 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](https://github.com/aws-observability/aws-otel-python-instrumentation/releases) einsehen.
1. 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 Röntgen-Trace-Anmerkungen und CloudWatch metrische Dimensionen umgewandelt.
1. 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.
1. 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 über HTTP verfügbar. Da Anwendungen in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. 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 über HTTP verfügbar. Da Anwendungen in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. 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.
1. 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.
1. 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](https://github.com/open-telemetry/opentelemetry-operator/issues/2302).
+ Für Django-Anwendungen sind zusätzliche Konfigurationen erforderlich, die in der [ OpenTelemetry Python-Dokumentation](https://opentelemetry-python.readthedocs.io/en/latest/examples/django/README.html) 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.
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
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**
1. 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.](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases)
1. 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"
```
1. 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 ](https://www.nuget.org/packages/AWS.Distro.OpenTelemetry.AutoInstrumentation) Repository. Anweisungen finden Sie in der [README-Datei](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/blob/main/src/AWS.Distro.OpenTelemetry.AutoInstrumentation/nuget-readme.md).
------
#### [ 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](#EC2-NodeJs-ESM) informieren, bevor Sie mit diesen Schritten beginnen.
**So instrumentieren Sie Ihre Node.js-Anwendungen im Rahmen der Aktivierung von Application Signals auf einer Amazon-EC2-Instance**
1. 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](https://github.com/aws-observability/aws-otel-js-instrumentation/releases) for Instrumentation einsehen. OpenTelemetry JavaScript
1. 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 Röntgen-Trace-Anmerkungen und CloudWatch metrische Dimensionen umgewandelt.
1. 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.
1. 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 über HTTP verfügbar. Da Anwendungen in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. 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 über HTTP verfügbar. Da Anwendungen in Amazon EC2 mit dem lokalen CloudWatch Agenten kommunizieren, sollten Sie diesen Wert auf festlegen `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. 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.
1. 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.
1. 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}}
```
1. (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](Application-Signals-MetricLogCorrelation.md). 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](Application-Signals-TraceLogCorrelation.md).
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](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations).
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
```
------
## Anwendungssignale auf Amazon EC2 mithilfe des Model Context Protocol (MCP) aktivieren
Sie können den MCP-Server ( CloudWatch Application Signals Model Context Protocol) verwenden, um Application Signals auf Ihren Amazon EC2 EC2-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](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-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 Idee zur Implementierung über
+ **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](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).
## (Optional) Überwachen Sie den Zustand Ihrer Anwendung
Sobald 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](Services.md).