

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.

# AWS X-Ray Dämon
<a name="xray-daemon"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

**Anmerkung**  
Sie können den CloudWatch Agenten jetzt verwenden, um Metriken, Protokolle und Traces von Amazon EC2 EC2-Instances und lokalen Servern zu sammeln. CloudWatch Agentenversion 1.300025.0 und höher können Traces von [OpenTelemetry](xray-instrumenting-your-app.md#xray-instrumenting-opentel)unserem [X-Ray-Client](xray-instrumenting-your-app.md#xray-instrumenting-xray-sdk) SDKs sammeln und an X-Ray senden. Wenn Sie den CloudWatch Agenten anstelle des AWS Distro for OpenTelemetry (ADOT) Collector oder des X-Ray-Daemons zum Sammeln von Traces verwenden, können Sie die Anzahl der verwalteten Agenten reduzieren. Weitere Informationen finden Sie unter dem Thema [CloudWatch Agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) im CloudWatch Benutzerhandbuch. 

Der AWS X-Ray Daemon ist eine Softwareanwendung, die den Datenverkehr auf dem UDP-Port 2000 überwacht, Rohsegmentdaten sammelt und sie an die API weiterleitet. AWS X-Ray Der Daemon arbeitet mit dem zusammen AWS X-Ray SDKs und muss laufen, damit die vom gesendeten Daten den X-Ray-Dienst erreichen SDKs können. Der X-Ray-Daemon ist ein Open-Source-Projekt. Du kannst dem Projekt folgen und Issues und Pull-Requests einreichen auf GitHub: [github. com/aws/aws-Xray-Daemon](https://github.com/aws/aws-xray-daemon)

Aktivieren AWS Lambda und AWS Elastic Beanstalk verwenden Sie die Integration dieser Dienste mit X-Ray, um den Daemon auszuführen. Lambda führt den Daemon jedes Mal automatisch aus, wenn eine Funktion für eine Stichprobenanforderung aufgerufen wird. [Verwenden Sie auf Elastic Beanstalk die `XRayEnabled` Konfigurationsoption](xray-daemon-beanstalk.md), um den Daemon auf den Instances in Ihrer Umgebung auszuführen. Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format). 

Um den X-Ray-Daemon lokal, lokal oder auf einem anderen Server [auszuführen](#xray-daemon-running), laden Sie ihn herunter AWS-Services, führen Sie ihn aus und [geben Sie ihm dann die Erlaubnis](#xray-daemon-permissions), Segmentdokumente auf X-Ray hochzuladen.

## Herunterladen des Daemons
<a name="xray-daemon-downloading"></a>

Sie können den Daemon von Amazon S3, Amazon ECR oder Docker Hub herunterladen und ihn dann lokal ausführen oder ihn beim Start auf einer Amazon EC2 EC2-Instance installieren.

------
#### [ Amazon S3 ]

**X-Ray-Daemon-Installationsprogramme und ausführbare Dateien**
+ **[Linux (ausführbar) — (sig) [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-3.x.zip](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-3.x.zip)](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-3.x.zip.sig)**
+ **Linux (RPM-Installationsprogramm)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.rpm](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.rpm)
+ **Linux (DEB-Installationsprogramm)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.deb](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.deb)
+ **Linux (ARM64, ausführbar)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-arm64-3.x.zip](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-arm64-3.x.zip)([sig](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-arm64-3.x.zip.sig))
+ **Linux (ARM64, RPM-Installationsprogramm)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-arm64-3.x.rpm](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-arm64-3.x.rpm)
+ **Linux (ARM64, DEB-Installationsprogramm)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-arm64-3.x.deb](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-arm64-3.x.deb)
+ **OS X (ausführbar)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-macos-3.x.zip](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-macos-3.x.zip)([sig](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-macos-3.x.zip.sig)) 
+ **Windows (ausführbar)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-process-3.x.zip](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-process-3.x.zip)([sig](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-process-3.x.zip.sig))
+ **Windows (Dienst)** — [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip)([sig](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip.sig))

Diese Links verweisen immer auf die neueste 3.x-Version des Daemons. Gehen Sie wie folgt vor, um eine bestimmte Version herunterzuladen:
+ Wenn Sie eine Version vor der Version herunterladen möchten`3.3.0`, `3.x` ersetzen Sie sie durch die Versionsnummer. Beispiel, `2.1.0`. Vor der Version `3.3.0` ist die einzig verfügbare Architektur`arm64`. Beispiel: `2.1.0` und `arm64`.
+ Wenn Sie eine Version nach der anderen herunterladen möchten`3.3.0`, `3.x` ersetzen Sie diese durch die Versionsnummer und `arch` den Architekturtyp. 

X-Ray-Assets werden in jeder unterstützten Region in Buckets repliziert. Um den Bucket zu verwenden, der Ihnen oder Ihren AWS Ressourcen am nächsten ist, ersetzen Sie die Region in den obigen Links durch Ihre Region.

```
https://s3.us-west-2.amazonaws.com/aws-xray-assets.us-west-2/xray-daemon/aws-xray-daemon-3.x.rpm
```

------
#### [ Amazon ECR ]

 Ab Version 3.2.0 ist der Daemon auf [Amazon](https://gallery.ecr.aws/xray/aws-xray-daemon) ECR zu finden. Bevor Sie ein Image abrufen, sollten Sie [Ihren Docker-Client bei der öffentlichen Registrierung von Amazon ECR authentifizieren](https://docs.aws.amazon.com/AmazonECR/latest/public/public-registries.html#public-registry-auth). 

Rufen Sie das neueste veröffentlichte 3.x-Versions-Tag ab, indem Sie den folgenden Befehl ausführen:

```
docker pull public.ecr.aws/xray/aws-xray-daemon:3.x
```

Frühere Versionen oder Alpha-Versionen können heruntergeladen werden, indem sie durch eine `alpha` oder eine bestimmte Versionsnummer ersetzt `3.x` werden. Es wird nicht empfohlen, in einer Produktionsumgebung ein Daemon-Image mit einem Alpha-Tag zu verwenden.

------
#### [ Docker Hub ]

Der Daemon ist auf [Docker](https://hub.docker.com/r/amazon/aws-xray-daemon) Hub zu finden. Führen Sie den folgenden Befehl aus, um die neueste veröffentlichte 3.x-Version herunterzuladen:

```
docker pull amazon/aws-xray-daemon:3.x
```

Frühere Versionen des Daemons können veröffentlicht werden, indem sie durch die gewünschte `3.x` Version ersetzt werden.

------

## Überprüfen der Signatur des Daemon-Archivs
<a name="xray-daemon-signature"></a>

GPG-Signatur-Dateien sind für Daemon-Komponenten in komprimierten ZIP-Archiven eingeschlossen. Der öffentliche Schlüssel befindet sich hier: [https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray.gpg](https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray.gpg).

Sie können den öffentlichen Schlüssel verwenden, um zu überprüfen, ob das Daemon-ZIP-Archiv ein Original und unverändert ist. Importieren Sie zunächst den öffentlichen Schlüssel mit [GnuPG](https://gnupg.org/index.html).

**So importieren Sie den öffentlichen Schlüssel**

1. Laden Sie den öffentlichen Schlüssel herunter.

   ```
   $ BUCKETURL=https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2
   $ wget $BUCKETURL/xray-daemon/aws-xray.gpg
   ```

1. Importieren Sie den öffentlichen Schlüssel in Ihren Schlüsselbund.

   ```
   $ gpg --import aws-xray.gpg
   gpg: /Users/me/.gnupg/trustdb.gpg: trustdb created
   gpg: key 7BFE036BFE6157D3: public key "AWS X-Ray <aws-xray@amazon.com>" imported
   gpg: Total number processed: 1
   gpg:               imported: 1
   ```

Verwenden Sie den importierten Schlüssel, um die Signatur des Daemon-ZIP-Archivs zu überprüfen.

**So überprüfen Sie die Signatur eines Archivs**

1. Laden Sie das Archiv und die Signaturdatei herunter.

   ```
   $ BUCKETURL=https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2
   $ wget $BUCKETURL/xray-daemon/aws-xray-daemon-linux-3.x.zip
   $ wget $BUCKETURL/xray-daemon/aws-xray-daemon-linux-3.x.zip.sig
   ```

1. Führen Sie `gpg --verify` aus, um die Signatur zu überprüfen.

   ```
   $ gpg --verify aws-xray-daemon-linux-3.x.zip.sig aws-xray-daemon-linux-3.x.zip
   gpg: Signature made Wed 19 Apr 2017 05:06:31 AM UTC using RSA key ID FE6157D3
   gpg: Good signature from "AWS X-Ray <aws-xray@amazon.com>"
   gpg: WARNING: This key is not certified with a trusted signature!
   gpg:          There is no indication that the signature belongs to the owner.
   Primary key fingerprint: EA6D 9271 FBF3 6990 277F  4B87 7BFE 036B FE61 57D3
   ```

Beachten Sie die Warnung zu vertrauenswürdigen Inhalten. Ein Schlüssel ist nur vertrauenswürdig, wenn Sie oder eine Person Ihres Vertrauens ihn signiert hat. Das bedeutet nicht, dass die Signatur ungültig ist, sondern nur, dass Sie den öffentlichen Schlüssel nicht überprüft haben.

## Ausführen des Daemons
<a name="xray-daemon-running"></a>

Führen Sie den Daemon lokal über eine Befehlszeile aus. Verwenden Sie die Option `-o` zur Ausführung im lokalen Modus und `-n` zum Festlegen der Region.

```
~/Downloads$ ./xray -o -n us-east-2
```

Detaillierte plattformspezifische Anweisungen finden Sie in den folgenden Themen:
+ **Linux (lokal)** — [Den X-Ray-Daemon unter Linux ausführen](xray-daemon-local.md#xray-daemon-local-linux)
+ **Windows (lokal)** — [Den X-Ray-Daemon unter Windows ausführen](xray-daemon-local.md#xray-daemon-local-windows)
+ **Elastic Beanstalk** — [Den X-Ray-Daemon ausführen auf AWS Elastic Beanstalk](xray-daemon-beanstalk.md)
+ **Amazon EC2** — [Den X-Ray-Daemon auf Amazon ausführen EC2](xray-daemon-ec2.md)
+ **Amazon ECS** — [Den X-Ray-Daemon auf Amazon ECS ausführen](xray-daemon-ecs.md)

Sie können mithilfe von Befehlszeilenoptionen oder einer Konfigurationsdatei das Verhalten des Daemons anpassen. Details dazu finden Sie unter [Konfiguration des AWS X-Ray Daemons](xray-daemon-configuration.md).

## Dem Daemon die Erlaubnis geben, Daten an X-Ray zu senden
<a name="xray-daemon-permissions"></a>

Der X-Ray-Daemon verwendet das AWS SDK, um Trace-Daten auf X-Ray hochzuladen, und benötigt dazu AWS Zugangsdaten mit entsprechender Genehmigung.

Auf Amazon EC2 verwendet der Daemon automatisch die Instance-Profilrolle der Instance. Informationen zu den Anmeldeinformationen, die für die lokale Ausführung des Daemons erforderlich sind, finden Sie unter Lokales [Ausführen Ihrer Anwendung](security_iam_service-with-iam.md#xray-permissions-local).

Wenn Sie an mehreren Orten (Anmeldeinformationsdatei, Instance-Profil oder Umgebungsvariablen) Anmeldeinformationen angeben, bestimmt die SDK-Anbieterkette, welche Anmeldeinformationen verwendet werden. Weitere Informationen zur Bereitstellung von Anmeldeinformationen für das SDK finden Sie unter [Spezifying Credentials](https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/#specifying-credentials) im *AWS SDK for Go Developer Guide*.

Die IAM-Rolle oder der Benutzer, zu der bzw. dem die Anmeldeinformationen des Daemons gehören, benötigt die Berechtigung zum Schreiben von Daten in den Service in Ihrem Namen.
+ Um den Daemon auf Amazon EC2 zu verwenden, erstellen Sie eine neue Instance-Profilrolle oder fügen Sie die verwaltete Richtlinie zu einer vorhandenen hinzu.
+ Um den Daemon auf Elastic Beanstalk zu verwenden, fügen Sie die verwaltete Richtlinie der Standard-Instance-Profilrolle von Elastic Beanstalk hinzu.
+ [Informationen zum lokalen Ausführen des Daemons finden Sie unter Lokales Ausführen Ihrer Anwendung.](security_iam_service-with-iam.md#xray-permissions-local)

Weitere Informationen finden Sie unter [Identitäts- und Zugriffsmanagement für AWS X-Ray](security-iam.md).

## X-Ray-Daemon-Protokolle
<a name="xray-daemon-logging"></a>

Der Daemon gibt Informationen über seine aktuelle Konfiguration und die Segmente aus, an die er sendet. AWS X-Ray

```
2016-11-24T06:07:06Z [Info] Initializing AWS X-Ray daemon 2.1.0
2016-11-24T06:07:06Z [Info] Using memory limit of 49 MB
2016-11-24T06:07:06Z [Info] 313 segment buffers allocated
2016-11-24T06:07:08Z [Info] Successfully sent batch of 1 segments (0.123 seconds)
2016-11-24T06:07:09Z [Info] Successfully sent batch of 1 segments (0.006 seconds)
```

Der Daemon gibt Protokolle standardmäßig an STDOUT aus. Wenn Sie den Daemon im Hintergrund ausführen, verwenden Sie zum Festlegen des Protokolldateipfades die Befehlszeilenoption `--log-file` oder eine Konfigurationsdatei. Sie können auch die Protokollierungsebene festlegen und die Protokoll-Rotation deaktivieren. Detaillierte Anweisungen finden Sie unter [Konfiguration des AWS X-Ray Daemons](xray-daemon-configuration.md).

Auf Elastic Beanstalk legt die Plattform den Speicherort der Daemon-Logs fest. Details dazu finden Sie unter [Den X-Ray-Daemon ausführen auf AWS Elastic Beanstalk](xray-daemon-beanstalk.md).

# Konfiguration des AWS X-Ray Daemons
<a name="xray-daemon-configuration"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

Sie können Befehlszeilenoptionen oder eine Konfigurationsdatei verwenden, um das Verhalten des X-Ray-Daemons anzupassen. Die meisten Optionen sind bei beiden Methoden verfügbar. Manche sind jedoch nur in Form von Konfigurationsdateien oder nur in der Befehlszeile verfügbar.

Um zu beginnen, müssen Sie nur die Option `-n` or kennen, mit der Sie die Region festlegen`--region`, die der Daemon verwendet, um Trace-Daten an X-Ray zu senden.

```
~/xray-daemon$ ./xray -n us-east-2
```

Wenn Sie den Daemon lokal ausführen, also nicht bei Amazon, können Sie die `-o` Option hinzufügen EC2, die Überprüfung der Anmeldeinformationen für das Instance-Profil zu überspringen, sodass der Daemon schneller bereit ist.

```
~/xray-daemon$ ./xray -o -n us-east-2
```

Mithilfe der restlichen Befehlszeilenoptionen können Sie die Protokollierung konfigurieren, einen anderen Port abhören, die vom Daemon nutzbare Speichermenge begrenzen oder eine Rolle annehmen, um Ablaufverfolgungsdaten an ein anderes Konto zu senden.

Sie können eine Konfigurationsdatei an den Daemon übergeben, um auf erweiterte Konfigurationsoptionen zuzugreifen und Dinge wie die Anzahl gleichzeitiger Aufrufe von X-Ray zu begrenzen, die Protokollrotation zu deaktivieren und Traffic an einen Proxy zu senden.

**Topics**
+ [Unterstützte Umgebungsvariablen](#xray-daemon-configuration-variables)
+ [Verwenden von Befehlszeilenoptionen](#xray-daemon-configuration-commandline)
+ [Verwendung einer Konfigurationsdatei](#xray-daemon-configuration-configfile)

## Unterstützte Umgebungsvariablen
<a name="xray-daemon-configuration-variables"></a>

Der X-Ray-Daemon unterstützt die folgenden Umgebungsvariablen:
+ `AWS_REGION`— Gibt den [AWS-Region](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration-region)des X-Ray-Dienstendpunkts an. 
+ `HTTPS_PROXY`— Gibt eine Proxyadresse an, über die der Daemon Segmente hochladen soll. Dies können entweder die DNS-Domänennamen oder die IP-Adressen und Portnummern sein, die von Ihren Proxy-Servern verwendet werden.

## Verwenden von Befehlszeilenoptionen
<a name="xray-daemon-configuration-commandline"></a>

Übergeben Sie diese Optionen an den Daemon, wenn Sie ihn lokal oder mit einem Benutzerdatenskript ausführen.

**Befehlszeilenoptionen**
+ `-b`, `--bind` — Hört auf Segmentdokumente an einem anderen UDP-Port.

  ```
  --bind "127.0.0.1:3000"
  ```

  Standard —`2000`.
+ `-t`, `--bind-tcp` — Warten Sie auf Anrufe an den X-Ray-Dienst an einem anderen TCP-Port.

  ```
  -bind-tcp "127.0.0.1:3000"
  ```

  Standard —`2000`.
+ `-c`, `--config` — Lädt eine Konfigurationsdatei aus dem angegebenen Pfad.

  ```
  --config "/home/ec2-user/xray-daemon.yaml"
  ```
+ `-f`, `--log-file` — Gibt Protokolle im angegebenen Dateipfad aus.

  ```
  --log-file "/var/log/xray-daemon.log"
  ```
+ `-l`, `--log-level` — Protokollebene, von der umfangreichsten bis zur geringsten Ausführlichkeit: dev, debug, info, warn, error, prod.

  ```
  --log-level warn
  ```

  Standard — `prod`
+ `-m`, `--buffer-memory` — Ändert die Speichermenge in MB, die Puffer verwenden können (mindestens 3).

  ```
  --buffer-memory 50
  ```

  Standard — 1% des verfügbaren Speichers.
+ `-o`, `--local-mode` — Suchen Sie nicht nach EC2 Instanz-Metadaten.
+ `-r`, `--role-arn` — Nehmen Sie die angegebene IAM-Rolle an, um Segmente auf ein anderes Konto hochzuladen.

  ```
  --role-arn "arn:aws:iam::123456789012:role/xray-cross-account"
  ```
+ `-a`, `--resource-arn` — Amazon-Ressourcenname (ARN) der AWS Ressource, auf der der Daemon ausgeführt wird.
+ `-p`, `--proxy-address` — Laden Sie Segmente AWS X-Ray über einen Proxy hoch. Das Protokoll des Proxyservers muss angegeben werden.

  ```
  --proxy-address "http://192.0.2.0:3000"
  ```
+ `-n`, `--region` — Sendet Segmente an den X-Ray-Dienst in einer bestimmten Region.
+ `-v`, `--version` — AWS X-Ray Daemon-Version anzeigen.
+ `-h`, `--help` — Zeigt den Hilfebildschirm an.

## Verwendung einer Konfigurationsdatei
<a name="xray-daemon-configuration-configfile"></a>

Sie können auch eine Datei im YAML-Format zur Konfiguration des Daemons verwenden. Übergeben Sie die Konfigurationsdatei mit der `-c`-Option an den Daemon.

```
~$ ./xray -c ~/xray-daemon.yaml
```

**Konfigurationsdateioptionen**
+ `TotalBufferSizeMB`— Maximale Puffergröße in MB (mindestens 3). Wählen Sie 0, um 1 % des Host-Speichers zu verwenden.
+ `Concurrency`— Maximale Anzahl gleichzeitiger Aufrufe AWS X-Ray zum Hochladen von Segmentdokumenten.
+ `Region`— Senden Sie Segmente an den AWS X-Ray Service in einer bestimmten Region.
+ `Socket`— Konfiguriert die Bindung des Daemons.
  + `UDPAddress`— Ändert den Port, auf dem der Daemon lauscht.
  + `TCPAddress`— Achten Sie auf [Anrufe an den X-Ray-Dienst](xray-api-sampling.md) an einem anderen TCP-Port.
+ `Logging`— Konfigurieren Sie das Protokollierungsverhalten.
  + `LogRotation`— Auf einstellen, `false` um die Protokollrotation zu deaktivieren.
  + `LogLevel`— Ändert die Protokollebene von der ausführlichsten zur geringsten:`dev`,`debug`, `info` oder`prod`,, `warn``error`,`prod`. Die Standardeinstellung ist`prod`, was äquivalent zu `info` ist.
  + `LogPath`— Gibt Protokolle im angegebenen Dateipfad aus.
+ `LocalMode`— Auf setzen, `true` um die Suche nach EC2 Instanz-Metadaten zu überspringen.
+ `ResourceARN`— Amazon-Ressourcenname (ARN) der AWS Ressource, auf der der Daemon ausgeführt wird.
+ `RoleARN`— Nehmen Sie die angegebene IAM-Rolle an, um Segmente auf ein anderes Konto hochzuladen.
+ `ProxyAddress`— Laden Sie Segmente AWS X-Ray über einen Proxy hoch.
+ `Endpoint`— Ändert den X-Ray-Dienstendpunkt, an den der Daemon Segmentdokumente sendet.
+ `NoVerifySSL`— Deaktiviert die Überprüfung des TLS-Zertifikats.
+ `Version`— Version des Formats der Daemon-Konfigurationsdatei. Die Version des Dateiformats ist ein **Pflichtfeld**.

**Example Xray-daemon.yaml**  
In dieser Konfigurationsdatei wird der Listening-Port des Daemons in 3000 geändert. Dazu werden die Prüfungen auf Instance-Metadaten deaktiviert, eine Rolle für den Upload von Segmenten eingerichtet und die Optionen für Region und Protokollierung geändert.  

```
Socket:
  UDPAddress: "127.0.0.1:3000"
  TCPAddress: "127.0.0.1:3000"
Region: "us-west-2"
Logging:
  LogLevel: "warn"
  LogPath: "/var/log/xray-daemon.log"
LocalMode: true
RoleARN: "arn:aws:iam::123456789012:role/xray-cross-account"
Version: 2
```

# Lokales Ausführen des X-Ray-Daemons
<a name="xray-daemon-local"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

Sie können den AWS X-Ray Daemon lokal unter Linux, macOS, Windows oder in einem Docker-Container ausführen. Führen Sie den Daemon aus, um Trace-Daten an X-Ray weiterzuleiten, wenn Sie Ihre instrumentierte Anwendung entwickeln und testen. Laden Sie den Daemon herunter und extrahieren Sie ihn. Diesbezügliche Anweisungen finden Sie [hier](xray-daemon.md#xray-daemon-downloading).

Wenn der Daemon lokal ausgeführt wird, kann er Anmeldeinformationen aus einer AWS SDK-Anmeldeinformationsdatei (`.aws/credentials`in Ihrem Benutzerverzeichnis) oder aus Umgebungsvariablen lesen. Weitere Informationen finden Sie unter [Dem Daemon die Erlaubnis geben, Daten an X-Ray zu senden](xray-daemon.md#xray-daemon-permissions).

Der Daemon lauscht an Port 2000 auf Daten. Sie können den Port und andere Optionen mithilfe einer Konfigurationsdatei und von Befehlszeilenoptionen ändern. Weitere Informationen finden Sie unter [Konfiguration des AWS X-Ray Daemons](xray-daemon-configuration.md).

## Den X-Ray-Daemon unter Linux ausführen
<a name="xray-daemon-local-linux"></a>

Sie können die ausführbare Datei des Daemons an der Befehlszeile ausführen. Verwenden Sie die Option `-o` zur Ausführung im lokalen Modus und `-n` zum Festlegen der Region.

```
~/xray-daemon$ ./xray -o -n us-east-2
```

Zum Ausführen des Daemons im Hintergrund verwenden Sie `&`.

```
~/xray-daemon$ ./xray -o -n us-east-2 &
```

Beenden Sie einen Daemonprozess, der im Hintergrund ausgeführt wird, mit `pkill`.

```
~$ pkill xray
```

## Den X-Ray-Daemon in einem Docker-Container ausführen
<a name="xray-daemon-local-docker"></a>

Um den Daemon lokal in einem Docker-Container auszuführen, speichern Sie den folgenden Text in einer Datei mit dem Namen `Dockerfile`. Laden Sie das vollständige [Beispielbild](https://gallery.ecr.aws/xray/aws-xray-daemon) auf Amazon ECR herunter. Weitere Informationen finden Sie unter [Den Daemon herunterladen](xray-daemon.md#xray-daemon-downloading).

**Example Dockerfile — Amazon Linux**  

```
FROM amazonlinux
RUN yum install -y unzip
RUN curl -o daemon.zip https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-3.x.zip
RUN unzip daemon.zip && cp xray /usr/bin/xray
ENTRYPOINT ["/usr/bin/xray", "-t", "0.0.0.0:2000", "-b", "0.0.0.0:2000"]
EXPOSE 2000/udp
EXPOSE 2000/tcp
```

Entwickeln Sie das Container-Image mit `docker build`.

```
~/xray-daemon$ docker build -t xray-daemon .
```

Führen Sie das Abbild in einem Container mit `docker run` aus.

```
~/xray-daemon$ docker run \
      --attach STDOUT \
      -v ~/.aws/:/root/.aws/:ro \
      --net=host \
      -e AWS_REGION=us-east-2 \
      --name xray-daemon \
      -p 2000:2000/udp \
      xray-daemon -o
```

Dieser Befehl verwendet die folgenden Optionen:
+ `--attach STDOUT`— Zeigt die Ausgabe des Daemons im Terminal an.
+ `-v ~/.aws/:/root/.aws/:ro`— Gewähren Sie dem Container nur Lesezugriff auf das `.aws` Verzeichnis, damit er Ihre AWS SDK-Anmeldeinformationen lesen kann.
+ `AWS_REGION=us-east-2`— Setzt die `AWS_REGION` Umgebungsvariable, um dem Daemon mitzuteilen, welche Region er verwenden soll.
+ `--net=host`— Hängt den Container an das `host` Netzwerk an. Container im Hostnetzwerk können miteinander kommunizieren, ohne Ports zu veröffentlichen.
+ `-p 2000:2000/udp`— Ordnen Sie den UDP-Port 2000 auf Ihrem Computer demselben Port auf dem Container zu. Dies ist für die Kommunikation von Containern in demselben Netzwerk nicht erforderlich. Sie können mit ihr aber Segmente [über die Befehlszeile](xray-api-sendingdata.md#xray-api-daemon) oder Anwendung, die nicht in Docker ausgeführt wird, zum Daemon senden.
+ `--name xray-daemon`— Benennen Sie den Container, `xray-daemon` anstatt einen zufälligen Namen zu generieren.
+ `-o`(nach dem Image-Namen) — Hängen Sie die `-o` Option an den Einstiegspunkt an, der den Daemon innerhalb des Containers ausführt. Diese Option weist den Daemon an, im lokalen Modus zu laufen, um zu verhindern, dass er versucht, EC2 Amazon-Instance-Metadaten zu lesen.

Um den Daemon zu beenden, verwenden Sie `docker stop`. Wenn Sie nach der Vornahme von Änderungen am `Dockerfile` ein neues Abbild erstellen, müssen Sie den vorhandenen Container löschen, damit Sie einen anderen mit demselben Namen erstellen können. Verwenden Sie `docker rm` zum Löschen des Containers.

```
$ docker stop xray-daemon
$ docker rm xray-daemon
```

## Den X-Ray-Daemon unter Windows ausführen
<a name="xray-daemon-local-windows"></a>

Sie können die ausführbare Datei des Daemons an der Befehlszeile ausführen. Verwenden Sie die Option `-o` zur Ausführung im lokalen Modus und `-n` zum Festlegen der Region.

```
> .\xray_windows.exe -o -n us-east-2
```

Verwenden Sie ein PowerShell Skript, um einen Dienst für den Daemon zu erstellen und auszuführen.

**Example PowerShell Skript — Windows**  

```
if ( Get-Service "AWSXRayDaemon" -ErrorAction SilentlyContinue ){
    sc.exe stop AWSXRayDaemon
    sc.exe delete AWSXRayDaemon
}
if ( Get-Item -path aws-xray-daemon -ErrorAction SilentlyContinue ) {
    Remove-Item -Recurse -Force aws-xray-daemon
}

$currentLocation = Get-Location
$zipFileName = "aws-xray-daemon-windows-service-3.x.zip"
$zipPath = "$currentLocation\$zipFileName"
$destPath = "$currentLocation\aws-xray-daemon"
$daemonPath = "$destPath\xray.exe"
$daemonLogPath = "C:\inetpub\wwwroot\xray-daemon.log"
$url = "https://s3.dualstack.us-west-2.amazonaws.com/aws-xray-assets.us-west-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip"

Invoke-WebRequest -Uri $url -OutFile $zipPath
Add-Type -Assembly "System.IO.Compression.Filesystem"
[io.compression.zipfile]::ExtractToDirectory($zipPath, $destPath)

sc.exe create AWSXRayDaemon binPath= "$daemonPath -f $daemonLogPath"
sc.exe start AWSXRayDaemon
```

## Den X-Ray-Daemon auf OS X ausführen
<a name="xray-daemon-local-osx"></a>

Sie können die ausführbare Datei des Daemons an der Befehlszeile ausführen. Verwenden Sie die Option `-o` zur Ausführung im lokalen Modus und `-n` zum Festlegen der Region.

```
~/xray-daemon$ ./xray_mac -o -n us-east-2
```

Zum Ausführen des Daemons im Hintergrund verwenden Sie `&`.

```
~/xray-daemon$ ./xray_mac -o -n us-east-2 &
```

Verwenden Sie `nohup`, um zu verhindern, dass der Daemon vorzeitig beendet wird, wenn das Terminal geschlossen wird.

```
~/xray-daemon$ nohup ./xray_mac &
```

# Den X-Ray-Daemon ausführen auf AWS Elastic Beanstalk
<a name="xray-daemon-beanstalk"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

Um Trace-Daten von Ihrer Anwendung an weiterzuleiten AWS X-Ray, können Sie den X-Ray-Daemon auf den Amazon EC2 EC2-Instances Ihrer Elastic Beanstalk Beanstalk-Umgebung ausführen. *Eine Liste der unterstützten Plattformen finden Sie unter [Configuring AWS X-Ray Debugging](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-configuration-debugging.html) im Developer Guide.AWS Elastic Beanstalk *

**Anmerkung**  
Der Daemon verwendet das Instance-Profil Ihrer Umgebung für Berechtigungen. Anweisungen zum Hinzufügen von Berechtigungen zum Elastic Beanstalk Beanstalk-Instance-Profil finden Sie unter. [Dem Daemon die Erlaubnis geben, Daten an X-Ray zu senden](xray-daemon.md#xray-daemon-permissions)

Elastic Beanstalk-Plattformen bieten eine Konfigurationsoption, die Sie so einrichten können, dass der Daemon automatisch ausgeführt wird. Sie können den Daemon in einer Konfigurationsdatei in Ihrem Quellcode oder durch Auswahl einer Option in der Elastic Beanstalk Beanstalk-Konsole aktivieren. Wenn Sie die Konfigurationsoption aktivieren, wird der Daemon in der Instance installiert und als Service ausgeführt.

Die auf Elastic Beanstalk-Plattformen enthaltene Version ist möglicherweise nicht die neueste Version. Dem [Thema "Unterstützte Plattformen"](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.platforms.html) können Sie entnehmen, welche Version des Daemons für Ihre Plattformkonfiguration verfügbar ist.

Elastic Beanstalk stellt den X-Ray-Daemon auf der Multicontainer Docker (Amazon ECS) -Plattform nicht bereit.

## Verwenden der Elastic Beanstalk X-Ray-Integration zum Ausführen des X-Ray-Daemons
<a name="xray-daemon-beanstalk-option"></a>

Verwenden Sie die Konsole, um die X-Ray-Integration zu aktivieren, oder konfigurieren Sie sie in Ihrem Anwendungsquellcode mit einer Konfigurationsdatei.

**So aktivieren Sie den X-Ray-Daemon in der Elastic Beanstalk Beanstalk-Konsole**

1. In der [Elastic-Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) öffnen.

1. Navigieren Sie zur [Managementkonsole für Ihre Umgebung](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-console.html).

1. Wählen Sie **Konfiguration**.

1. Wählen Sie **Software Settings (Softwareeinstellungen)**.

1. Wählen Sie für **X-Ray daemon** **Enabled**.

1. Wählen Sie **Anwenden** aus.

Sie können eine Konfigurationsdatei in Ihren Quellcode aufnehmen, um die Konfiguration zwischen verschiedenen Umgebungen übertragbar zu gestalten.

**Example .ebextensions/xray-daemon.config**  

```
option_settings:
  aws:elasticbeanstalk:xray:
    XRayEnabled: true
```

Elastic Beanstalk übergibt eine Konfigurationsdatei an den Daemon und gibt die Protokolle an einem Standardspeicherort aus.

**Auf Windows Server-Plattformen**
+ **Konfigurationsdatei —** `C:\Program Files\Amazon\XRay\cfg.yaml`
+ **Protokolle** — `c:\Program Files\Amazon\XRay\logs\xray-service.log`

**Auf Linux-Plattformen**
+ **Konfigurationsdatei** — `/etc/amazon/xray/cfg.yaml`
+ **Protokolle** — `/var/log/xray/xray.log`

Elastic Beanstalk bietet Tools zum Abrufen von Instance-Logs über die Befehlszeile AWS-Managementkonsole oder. Sie können Elastic Beanstalk anweisen, die X-Ray-Daemon-Logs einzubeziehen, indem Sie eine Aufgabe mit einer Konfigurationsdatei hinzufügen.

**Example .ebextensions/xray-logs.config – Linux**  

```
files:
  "/opt/elasticbeanstalk/tasks/taillogs.d/xray-daemon.conf" :
    mode: "000644"
    owner: root
    group: root
    content: |
      /var/log/xray/xray.log
```

**Example .ebextensions/xray-logs.config – Windows Server**  

```
files:
  "c:/Program Files/Amazon/ElasticBeanstalk/config/taillogs.d/xray-daemon.conf" :
    mode: "000644"
    owner: root
    group: root
    content: |
      c:\Progam Files\Amazon\XRay\logs\xray-service.log
```

Weitere Informationen finden Sie im *AWS Elastic Beanstalk Developer Guide* unter [Logs aus den Amazon EC2 EC2-Instances Ihrer Elastic Beanstalk Beanstalk-Umgebung anzeigen](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.logging.html).

## Manuelles Herunterladen und Ausführen des X-Ray-Daemons (fortgeschritten)
<a name="xray-daemon-beanstalk-manual"></a>

Wenn der X-Ray-Daemon für Ihre Plattformkonfiguration nicht verfügbar ist, können Sie ihn von Amazon S3 herunterladen und mit einer Konfigurationsdatei ausführen.

Verwenden Sie eine Elastic Beanstalk Beanstalk-Konfigurationsdatei, um den Daemon herunterzuladen und auszuführen.

**Example .ebextensions/xray.config – Linux**  

```
commands:
  01-stop-tracing:
    command: yum remove -y xray
    ignoreErrors: true
  02-copy-tracing:
    command: curl https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.rpm -o /home/ec2-user/xray.rpm
  03-start-tracing:
    command: yum install -y /home/ec2-user/xray.rpm

files:
  "/opt/elasticbeanstalk/tasks/taillogs.d/xray-daemon.conf" :
    mode: "000644"
    owner: root
    group: root
    content: |
      /var/log/xray/xray.log
  "/etc/amazon/xray/cfg.yaml" :
    mode: "000644"
    owner: root
    group: root
    content: |
      Logging:
        LogLevel: "debug"
      Version: 2
```

**Example .ebextensions/xray.config – Windows Server**  

```
container_commands:
  01-execute-config-script:
    command: Powershell.exe -ExecutionPolicy Bypass -File c:\\temp\\installDaemon.ps1
    waitAfterCompletion: 0
 
files:
  "c:/temp/installDaemon.ps1":
    content: |
      if ( Get-Service "AWSXRayDaemon" -ErrorAction SilentlyContinue ) {
          sc.exe stop AWSXRayDaemon
          sc.exe delete AWSXRayDaemon
      }

      $targetLocation = "C:\Program Files\Amazon\XRay"
      if ((Test-Path $targetLocation) -eq 0) {
          mkdir $targetLocation
      }

      $zipFileName = "aws-xray-daemon-windows-service-3.x.zip"
      $zipPath = "$targetLocation\$zipFileName"
      $destPath = "$targetLocation\aws-xray-daemon"
      if ((Test-Path $destPath) -eq 1) {
          Remove-Item -Recurse -Force $destPath
      }

      $daemonPath = "$destPath\xray.exe"
      $daemonLogPath = "$targetLocation\xray-daemon.log"
      $url = "https://s3.dualstack.us-west-2.amazonaws.com/aws-xray-assets.us-west-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip"

      Invoke-WebRequest -Uri $url -OutFile $zipPath
      Add-Type -Assembly "System.IO.Compression.Filesystem"
      [io.compression.zipfile]::ExtractToDirectory($zipPath, $destPath)

      New-Service -Name "AWSXRayDaemon" -StartupType Automatic -BinaryPathName "`"$daemonPath`" -f `"$daemonLogPath`""
      sc.exe start AWSXRayDaemon
    encoding: plain
  "c:/Program Files/Amazon/ElasticBeanstalk/config/taillogs.d/xray-daemon.conf" :
    mode: "000644"
    owner: root
    group: root
    content: |
      C:\Program Files\Amazon\XRay\xray-daemon.log
```

Diese Beispiele fügen auch die Log-Datei des Daemons zur Elastic Beanstalk-Task für die Tail-Logs hinzu, sodass sie enthalten ist, wenn Sie Logs mit der Konsole oder der Elastic Beanstalk Beanstalk-Befehlszeilenschnittstelle (EB CLI) anfordern.

# Den X-Ray-Daemon auf Amazon ausführen EC2
<a name="xray-daemon-ec2"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

Sie können den X-Ray-Daemon auf den folgenden Betriebssystemen bei Amazon EC2 ausführen:
+ Amazon Linux
+ Ubuntu
+ Windows Server (2012 R2 und neuer)

Verwenden Sie ein Instanzprofil, um dem Daemon die Erlaubnis zu erteilen, Trace-Daten auf X-Ray hochzuladen. Weitere Informationen finden Sie unter [Dem Daemon die Erlaubnis geben, Daten an X-Ray zu senden](xray-daemon.md#xray-daemon-permissions).

Verwenden Sie ein Benutzerdatenskript, um den Daemon automatisch auszuführen, wenn Sie die Instance starten.

**Example Benutzerdatenskript – Linux**  

```
#!/bin/bash
curl https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.rpm -o /home/ec2-user/xray.rpm
yum install -y /home/ec2-user/xray.rpm
```

**Example Benutzerdatenskript – Windows Server**  

```
<powershell>
if ( Get-Service "AWSXRayDaemon" -ErrorAction SilentlyContinue ) {
    sc.exe stop AWSXRayDaemon
    sc.exe delete AWSXRayDaemon
}

$targetLocation = "C:\Program Files\Amazon\XRay"
if ((Test-Path $targetLocation) -eq 0) {
    mkdir $targetLocation
}

$zipFileName = "aws-xray-daemon-windows-service-3.x.zip"
$zipPath = "$targetLocation\$zipFileName"
$destPath = "$targetLocation\aws-xray-daemon"
if ((Test-Path $destPath) -eq 1) {
    Remove-Item -Recurse -Force $destPath
}

$daemonPath = "$destPath\xray.exe"
$daemonLogPath = "$targetLocation\xray-daemon.log"
$url = "https://s3.dualstack.us-west-2.amazonaws.com/aws-xray-assets.us-west-2/xray-daemon/aws-xray-daemon-windows-service-3.x.zip"

Invoke-WebRequest -Uri $url -OutFile $zipPath
Add-Type -Assembly "System.IO.Compression.Filesystem"
[io.compression.zipfile]::ExtractToDirectory($zipPath, $destPath)

New-Service -Name "AWSXRayDaemon" -StartupType Automatic -BinaryPathName "`"$daemonPath`" -f `"$daemonLogPath`""
sc.exe start AWSXRayDaemon
</powershell>
```

# Den X-Ray-Daemon auf Amazon ECS ausführen
<a name="xray-daemon-ecs"></a>

**Anmerkung**  
 SDK/Daemon X-Ray-Wartungshinweis — Am 25. Februar 2026 wechselt das AWS X-Ray SDKs/Daemon in den Wartungsmodus, in dem die Versionen von X-Ray SDK und Daemon auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray-Instrumentierung zu OpenTelemetry Instrumentierung](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).

Erstellen Sie in Amazon ECS ein Docker-Image, das den X-Ray-Daemon ausführt, laden Sie es in ein Docker-Image-Repository hoch und stellen Sie es dann in Ihrem Amazon ECS-Cluster bereit. Sie können Ihrer Anwendung über Port-Zuordnungen und Netzwerkmodus-Einstellungen in Ihrer Aufgabendefinitionsdatei die Kommunikation mit dem Daemon-Container ermöglichen.

## Verwenden des offiziellen -Docker-Image
<a name="xray-daemon-ecs-image"></a>

X-Ray stellt ein [Docker-Container-Image](https://gallery.ecr.aws/xray/aws-xray-daemon) auf Amazon ECR bereit, das Sie zusammen mit Ihrer Anwendung bereitstellen können. Weitere Informationen finden [Sie unter Den Daemon herunterladen](xray-daemon.md#xray-daemon-downloading).

**Example Aufgabendefinition**  

```
    {
      "name": "xray-daemon",
      "image": "amazon/aws-xray-daemon",
      "cpu": 32,
      "memoryReservation": 256,
      "portMappings" : [
          {
              "hostPort": 0,
              "containerPort": 2000,
              "protocol": "udp"
          }
       ]
    }
```

## Entwickeln und Erstellen eines Docker-Images
<a name="xray-daemon-ecs-build"></a>

Bei einer benutzerdefinierten Konfiguration müssen Sie möglicherweise ein eigenes Docker-Image definieren.

Fügen Sie verwaltete Richtlinien zu Ihrer Aufgabenrolle hinzu, um dem Daemon die Erlaubnis zu erteilen, Trace-Daten auf X-Ray hochzuladen. Weitere Informationen finden Sie unter [Dem Daemon die Erlaubnis geben, Daten an X-Ray zu senden](xray-daemon.md#xray-daemon-permissions).

Erstellen Sie mit einer der folgenden Dockerfiles ein Abbild, mit dem der Daemon ausführt wird.

**Example Dockerfile — Amazon Linux**  

```
FROM amazonlinux
RUN yum install -y unzip
RUN curl -o daemon.zip https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-linux-3.x.zip
RUN unzip daemon.zip && cp xray /usr/bin/xray
ENTRYPOINT ["/usr/bin/xray", "-t", "0.0.0.0:2000", "-b", "0.0.0.0:2000"]
EXPOSE 2000/udp
EXPOSE 2000/tcp
```

**Anmerkung**  
Die Flags `-t` und `-b` sind erforderlich, um eine Bindungsadresse anzugeben, die den Loopback einer Multi-Container-Umgebung überwacht.

**Example Dockerfile — Ubuntu**  
Für Debian-Derivate müssen Sie auch Zertifikate installieren, die von einer Zertifizierungsstelle (Certificate Authority, CA) ausgegeben wurden, um Probleme beim Herunterladen des Installationsprogramms zu vermeiden.  

```
FROM ubuntu:16.04
RUN apt-get update && apt-get install -y --force-yes --no-install-recommends apt-transport-https curl ca-certificates wget && apt-get clean && apt-get autoremove && rm -rf /var/lib/apt/lists/*
RUN wget https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.deb
RUN dpkg -i aws-xray-daemon-3.x.deb
ENTRYPOINT ["/usr/bin/xray", "--bind=0.0.0.0:2000", "--bind-tcp=0.0.0.0:2000"]
EXPOSE 2000/udp
EXPOSE 2000/tcp
```

In Ihrer Aufgabendefinition hängt die Konfiguration von dem Netzwerkmodus ab, den Sie tatsächlich nutzen. Brückennetzwerke sind die Standardeinstellung und können in Ihrer Standard-VPC verwendet werden. Stellen Sie in einem Bridge-Netzwerk die `AWS_XRAY_DAEMON_ADDRESS` Umgebungsvariable so ein, dass sie dem X-Ray SDK mitteilt, auf welchen Container-Port verwiesen werden soll, und legen Sie den Host-Port fest. Sie können beispielsweise UDP-Port 2000 veröffentlichen und einen Link von Ihrem Anwendungs-Container zum Daemon-Container erstellen. 

**Example Aufgabendefinition**  

```
    {
      "name": "xray-daemon",
      "image": "123456789012.dkr.ecr.us-east-2.amazonaws.com/xray-daemon",
      "cpu": 32,
      "memoryReservation": 256,
      "portMappings" : [
          {
              "hostPort": 0,
              "containerPort": 2000,
              "protocol": "udp"
          }
       ]
    },
    {
      "name": "scorekeep-api",
      "image": "123456789012.dkr.ecr.us-east-2.amazonaws.com/scorekeep-api",
      "cpu": 192,
      "memoryReservation": 512,
      "environment": [
          { "name" : "AWS_REGION", "value" : "us-east-2" },
          { "name" : "NOTIFICATION_TOPIC", "value" : "arn:aws:sns:us-east-2:123456789012:scorekeep-notifications" },
          { "name" : "AWS_XRAY_DAEMON_ADDRESS", "value" : "xray-daemon:2000" }
      ],
      "portMappings" : [
          {
              "hostPort": 5000,
              "containerPort": 5000
          }
      ],
      "links": [
        "xray-daemon"
      ]
    }
```

Wenn Sie Ihren Cluster im privaten Subnetz einer VPC ausführen, können Sie Ihren Containern mit dem [`awsvpc`-Netzwerkmodus](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) einer Elastic Network-Schnittstelle (ENI) zuweisen. Auf diese Weise können Sie die Nutzung von Links vermeiden. Lassen Sie den Host-Port in den Port-Zuordnungen, dem Link und der Umgebungsvariable `AWS_XRAY_DAEMON_ADDRESS` weg.

**Example VPC-Aufgabendefinition**  

```
{
    "family": "scorekeep",
    "networkMode":"awsvpc",
    "containerDefinitions": [
        {
          "name": "xray-daemon",
          "image": "123456789012.dkr.ecr.us-east-2.amazonaws.com/xray-daemon",
          "cpu": 32,
          "memoryReservation": 256,
          "portMappings" : [
              {
                  "containerPort": 2000,
                  "protocol": "udp"
              }
          ]
        },
        {
            "name": "scorekeep-api",
            "image": "123456789012.dkr.ecr.us-east-2.amazonaws.com/scorekeep-api",
            "cpu": 192,
            "memoryReservation": 512,
            "environment": [
                { "name" : "AWS_REGION", "value" : "us-east-2" },
                { "name" : "NOTIFICATION_TOPIC", "value" : "arn:aws:sns:us-east-2:123456789012:scorekeep-notifications" }
            ],
            "portMappings" : [
                {
                    "containerPort": 5000
                }
            ]
        }
    ]
}
```

## Befehlszeilenoptionen in der Amazon ECS-Konsole konfigurieren
<a name="xray-daemon-ecs-cmdline"></a>

Befehlszeilenoptionen überschreiben Konflikte in der Konfigurationsdatei Ihres Abbildes. Befehlszeilenoptionen werden normalerweise für lokale Tests verwendet, können aber auch aus praktischen Gründen beim Festlegen von Umgebungsvariablen oder zur Steuerung des Startvorgangs verwendet werden. 

Durch Hinzufügen von Befehlszeilenoptionen aktualisieren Sie den Docker `CMD`, der an den Container übergeben wird. Weitere Informationen finden Sie in der [Referenz zu docker run](https://docs.docker.com/engine/reference/run/#overriding-dockerfile-image-defaults).

**So legen Sie eine Befehlszeilenoption fest**

1. Öffnen Sie die klassische Amazon ECS-Konsole unter [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Wählen Sie auf der Navigationsleiste die Region aus, in der Ihre Aufgabendefinition enthalten ist.

1. Wählen Sie im Navigationsbereich **Task Definitions** aus.

1. Aktivieren Sie auf der Seite **Task Definitions** das Kontrollkästchen links neben der Aufgabendefinition, die Sie überarbeiten möchten, und wählen Sie dann **Create new revision** aus.

1. Wählen Sie auf der Seite **Create new revision of Task Definition (Neue Revision der Aufgabendefinition erstellen)** den Container aus.

1. Fügen Sie im Abschnitt **ENVIRONMENT** Ihre durch Komma getrennte Liste von Befehlszeilenoptionen zum Feld **Command** hinzu.

1. Wählen Sie **Aktualisieren** aus.

1. Überprüfen Sie die Informationen und wählen Sie dann **Create** aus.

Das folgende Beispiel zeigt, wie eine durch Kommas getrennte Befehlszeilenoption für die Option `RoleARN` geschrieben wird. Die `RoleARN` Option setzt die angegebene IAM-Rolle voraus, um Segmente auf ein anderes Konto hochzuladen.

**Example**  

```
--role-arn, arn:aws:iam::123456789012:role/xray-cross-account
```

Weitere Informationen zu den verfügbaren Befehlszeilenoptionen in X-Ray finden Sie unter [Konfiguration des AWS X-Ray Daemons](xray-daemon-configuration.md).