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 SDK für Python
**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).
Das X-Ray-SDK für Python ist eine Bibliothek für Python-Webanwendungen, die Klassen und Methoden zum Generieren und Senden von Trace-Daten an den X-Ray-Daemon bereitstellt. Zu den Trace-Daten gehören Informationen über eingehende HTTP-Anfragen, die von der Anwendung bedient werden, sowie über Aufrufe, die die Anwendung mithilfe des AWS SDK, der HTTP-Clients oder eines SQL-Datenbankkonnektors an Downstream-Dienste sendet. Sie können Segmente auch manuell erstellen und Debug-Informationen Anmerkungen und Metadaten hinzufügen.
Sie können das SDK mit `pip` herunterladen.
```
$ pip install aws-xray-sdk
```
**Anmerkung**
Das X-Ray SDK für Python ist ein Open-Source-Projekt. Du kannst das Projekt verfolgen und Issues und Pull-Requests einreichen auf GitHub: [github. com/aws/aws](https://github.com/aws/aws-xray-sdk-python)- xray-sdk-python
Wenn Sie Django oder Flask nutzen, beginnen Sie, indem Sie [die SDK-Middleware zu Ihrer Anwendung hinzufügen](xray-sdk-python-middleware.md), um eingehende Anforderungen zu verfolgen. Der Middleware erstellt für jede verfolgte Anforderung ein [Segment](xray-concepts.md#xray-concepts-segments) und vervollständigt das Segment, nachdem die Antwort gesendet wurde. Während das Segment geöffnet ist, können Sie die SDK-Client-Methoden nutzen, um dem Segment Informationen hinzuzufügen, Untersegmente zu erstellen und nachgelagerte Aufrufe rückzuverfolgen. Das SDK erfasst auch automatisch Ausnahmen, die Ihre Anwendung ausgibt, während das Segment geöffnet ist. Bei anderen Anwendungen können Sie [Segmente manuell erstellen](xray-sdk-python-middleware.md#xray-sdk-python-middleware-manual).
Bei Lambda-Funktionen, die von einer instrumentierten Anwendung oder einem Dienst aufgerufen werden, liest Lambda den [Tracing-Header und verfolgt automatisch Sampling-Anfragen](xray-concepts.md#xray-concepts-tracingheader). Für andere Funktionen können Sie [Lambda so konfigurieren](xray-services-lambda.md), dass eingehende Anfragen abgefragt und verfolgt werden. In beiden Fällen erstellt Lambda das Segment und stellt es dem X-Ray SDK zur Verfügung.
**Anmerkung**
Auf Lambda ist das X-Ray SDK optional. Wenn Sie es nicht in Ihrer Funktion verwenden, enthält Ihre Service-Map immer noch einen Knoten für den Lambda-Service und einen für jede Lambda-Funktion. Durch Hinzufügen des SDK können Sie Ihren Funktionscode instrumentieren, um Untersegmente zu dem von Lambda aufgezeichneten Funktionssegment hinzuzufügen. Weitere Informationen finden Sie unter [AWS Lambda und AWS X-Ray](xray-services-lambda.md).
Ein Beispiel [Worker](scorekeep-lambda.md#scorekeep-lambda-worker) für eine in Lambda instrumentierte Python-Funktion finden Sie unter.
Verwenden Sie als Nächstes das X-Ray-SDK für Python, um Downstream-Aufrufe zu instrumentieren, indem Sie die [Bibliotheken Ihrer Anwendung patchen](xray-sdk-python-patching.md). Das SDK unterstützt die folgenden Bibliotheken.
**Unterstützte Bibliotheken**
+ `[botocore](https://pypi.python.org/pypi/botocore)`, `[boto3](https://pypi.python.org/pypi/boto3)` — AWS SDK für Python (Boto) Instrumenten-Clients.
+ `[pynamodb](https://pypi.python.org/pypi/pynamodb/)`— Instrument PynamoDB-Version des Amazon DynamoDB-Clients.
+ `[aiobotocore](https://pypi.python.org/pypi/aiobotocore)`, `[aioboto3](https://pypi.python.org/pypi/aioboto3)` — [Asyncio-integrierte](https://docs.python.org/3/library/asyncio.html) Versionen des SDK für Python-Clients.
+ `[requests](https://pypi.python.org/pypi/requests)`, `[aiohttp](https://pypi.python.org/pypi/aiohttp)` — Instrumentieren Sie HTTP-Clients auf hoher Ebene.
+ `[httplib](https://docs.python.org/2/library/httplib.html)`, [https://docs.python.org/3/library/http.client.html](https://docs.python.org/3/library/http.client.html)— Instrumentieren Sie HTTP-Clients auf niedriger Ebene und die Bibliotheken auf höherer Ebene, die sie verwenden.
+ `[sqlite3](https://docs.python.org/3/library/sqlite3.html)`— SQLite Instrumenten-Clients.
+ `[mysql-connector-python](https://pypi.python.org/pypi/mysql-connector-python)`— Instrumentieren Sie MySQL-Clients.
+ `[pg8000](https://pypi.org/project/pg8000/)`— Instrument Pure-Python PostgreSQL-Schnittstelle.
+ `[psycopg2](https://pypi.org/project/psycopg2/)`— Instrument PostgreSQL-Datenbankadapter.
+ `[pymongo](https://pypi.org/project/pymongo/)`— Instrumentieren Sie MongoDB-Clients.
+ `[pymysql](https://pypi.org/project/PyMySQL/)`— Instrument PyMy SQL-basierte Clients für MySQL und MariaDB.
Immer wenn Ihre Anwendung eine SQL-Datenbank oder andere HTTP-Dienste aufruft, zeichnet das SDK Informationen über den Aufruf in einem Untersegment auf. AWS AWS-Services und die Ressourcen, auf die Sie innerhalb der Dienste zugreifen, werden in der Trace-Map als Downstream-Knoten angezeigt, sodass Sie Fehler und Drosselungsprobleme bei einzelnen Verbindungen leichter identifizieren können.
Nachdem Sie das SDK verwendet haben, passen Sie sein Verhalten an, indem Sie [den Rekorder und die Middleware konfigurieren](xray-sdk-python-configuration.md). Sie können Plugins zum Festhalten von Daten über die Datenverarbeitungsressourcen, auf denen Ihre Anwendung ausgeführt wird, hinzufügen, das Samplingverhalten durch Samplingregeln anpassen und Protokollebenen einrichten, um mehr oder weniger Informationen von dem SDK in Ihren Anwendungsprotokollen zu sehen.
Zeichnen Sie zusätzliche Informationen zu Anforderungen und den Aufgaben, die Ihre Anwendung ausführt, in [Anmerkungen und Metadaten](xray-sdk-python-segment.md) auf. Anmerkungen sind einfache Schlüsselwertpaare, die für die Verwendung mit [Filterausdrücken](xray-console-filters.md) indiziert werden, damit Sie nach Ablaufverfolgen mit bestimmten Daten suchen können. Metadateneinträge sind weniger einschränkend und können ganze Objekte und Arrays aufzeichnen – alle Daten, die in eine JSON zusammengefasst werden können.
**Anmerkungen und Metadaten**
Anmerkungen und Metadaten sind beliebiger Text, den Sie Segmenten mit dem X-Ray SDK hinzufügen. Anmerkungen werden für die Verwendung mit Filterausdrücken indexiert. Metadaten werden nicht indexiert, können aber im Rohsegment mit der X-Ray-Konsole oder API angezeigt werden. Jeder, dem Sie Lesezugriff auf X-Ray gewähren, kann diese Daten einsehen.
Wenn Sie viele instrumentierten Clients in Ihrem Code haben, kann ein einzelnes Anforderungssegmente viele Untersegmente enthalten, eines für jeden Aufruf mit einem instrumentierten Client. Sie können Untersegmente organisieren und gruppieren, indem Sie Client-Aufrufe in [benutzerdefinierten Untersegmenten](xray-sdk-python-subsegments.md) zusammenfassen. Sie können ein benutzerdefiniertes Untersegment für die gesamte Funktion oder einen beliebigen Bereich des Codes erstellen. Sie können dann Metadaten und Anmerkungen im Untersegment aufzeichnen, anstatt alles in das übergeordnete Segment zu schreiben.
Eine Referenzdokumentation zu den Klassen und Methoden des SDK finden Sie in der [API-Referenz zum AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray-sdk-for-python/latest/reference).
## Voraussetzungen
Das X-Ray-SDK für Python unterstützt die folgenden Sprach- und Bibliotheksversionen.
+ **Python** — 2.7, 3.4 und neuer
+ **Django** — 1.10 und neuer
+ **Flask — 0.10** und neuer
+ **aiohttp** — 2.3.0 und neuer
+ **AWS SDK für Python (Boto)**— 1.4.0 und neuer
+ **botocore** — 1.5.0 und neuer
+ **enum** — 0.4.7 und neuer, für Python-Versionen 3.4.0 und älter
+ **jsonpickle** — 1.0.0 und neuer
+ **setuptools** — 40.6.3 und neuer
+ **wrapt — 1.11.0** und neuer
## Abhängigkeitsmanagement
Das X-Ray-SDK für Python ist erhältlich unter`pip`.
+ **Package** — `aws-xray-sdk`
Fügen Sie das SDK in Ihrer `requirements.txt`-Datei als abhängige Komponente hinzu.
**Example requirements.txt**
```
aws-xray-sdk==2.4.2
boto3==1.4.4
botocore==1.5.55
Django==1.11.3
```
Wenn Sie Elastic Beanstalk für die Bereitstellung Ihrer Anwendung verwenden, installiert Elastic Beanstalk alle Pakete automatisch. `requirements.txt`
# Konfiguration des X-Ray-SDK für Python
**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).
Das X-Ray-SDK für Python hat eine Klasse namens`xray_recorder`, die den globalen Rekorder bereitstellt. Sie können die globale Aufzeichnung so konfigurieren, dass die Middleware, die Segmente für eingehende HTTP-Aufrufe erstellt, angepasst wird.
**Topics**
+ [Service-Plugins](#xray-sdk-python-configuration-plugins)
+ [Regeln für die Probenahme](#xray-sdk-python-configuration-sampling)
+ [Protokollierung](#xray-sdk-python-configuration-logging)
+ [Konfiguration des Recorders im Code](#xray-sdk-python-middleware-configuration-code)
+ [Konfigurieren des Recorders mit Django](#xray-sdk-python-middleware-configuration-django)
+ [Umgebungsvariablen](#xray-sdk-python-configuration-envvars)
## Service-Plugins
Wird verwendet`plugins`, um Informationen über den Dienst aufzuzeichnen, der Ihre Anwendung hostet.
**Plugins**
+ Amazon EC2 — `EC2Plugin` fügt die Instance-ID, die Availability Zone und die CloudWatch Logs-Gruppe hinzu.
+ Elastic Beanstalk — `ElasticBeanstalkPlugin` fügt den Umgebungsnamen, die Versionsbezeichnung und die Bereitstellungs-ID hinzu.
+ Amazon ECS — `ECSPlugin` fügt die Container-ID hinzu.
![\[Segment - Scorekeep overview showing Elastic Beanstalk and EC2 deployment details.\]](http://docs.aws.amazon.com/de_de/xray/latest/devguide/images/scorekeep-PUTrules-segment-resources-python09.png)
Um ein Plugin zu verwenden, rufen Sie `configure` im `xray_recorder` auf.
```
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
xray_recorder.configure(service='My app')
plugins = ('ElasticBeanstalkPlugin', 'EC2Plugin')
xray_recorder.configure(plugins=plugins)
patch_all()
```
**Anmerkung**
Da `plugins` sie als Tupel übergeben werden, sollten Sie bei der Angabe eines einzelnen Plug-ins unbedingt ein `,` abschließendes Zeichen angeben. Beispiel: `plugins = ('EC2Plugin',)`
Sie können auch [Umgebungsvariablen](#xray-sdk-python-configuration-envvars), die Vorrang über Werte im Code haben, zur Konfiguration des Recorders verwenden.
Konfigurieren Sie Plugins vor [Patch-Bibliotheken](xray-sdk-python-patching.md), um nachgeschaltete Aufrufe aufzuzeichnen.
Das SDK verwendet auch Plugin-Einstellungen, um das `origin` Feld für das Segment festzulegen. Dies gibt den AWS Ressourcentyp an, auf dem Ihre Anwendung ausgeführt wird. Wenn Sie mehrere Plugins verwenden, verwendet das SDK die folgende Auflösungsreihenfolge, um den Ursprung zu bestimmen: ElasticBeanstalk > EKS > ECS > EC2.
## Regeln für die Probenahme
Das SDK verwendet die Sampling-Regeln, die Sie in der X-Ray-Konsole definieren, um zu bestimmen, welche Anfragen aufgezeichnet werden sollen. Die Standardregel verfolgt die erste Anfrage jede Sekunde und fünf Prozent aller weiteren Anfragen aller Dienste, die Traces an X-Ray senden. [Erstellen Sie zusätzliche Regeln in der X-Ray-Konsole](xray-console-sampling.md), um die Menge der aufgezeichneten Daten für jede Ihrer Anwendungen anzupassen.
Das SDK wendet benutzerdefinierte Regeln in der Reihenfolge an, in der sie definiert sind. Wenn eine Anfrage mehreren benutzerdefinierten Regeln entspricht, wendet das SDK nur die erste Regel an.
**Anmerkung**
Wenn das SDK X-Ray nicht erreichen kann, um Sampling-Regeln abzurufen, kehrt es zu einer lokalen Standardregel zurück, die die erste Anfrage pro Sekunde und fünf Prozent aller zusätzlichen Anfragen pro Host vorsieht. Dies kann passieren, wenn der Host nicht berechtigt ist APIs, Sampling aufzurufen, oder wenn er keine Verbindung zum X-Ray-Daemon herstellen kann, der als TCP-Proxy für API-Aufrufe durch das SDK fungiert.
Sie können das SDK auch so konfigurieren, dass Sampling-Regeln aus einem JSON-Dokument geladen werden. Das SDK kann lokale Regeln als Backup für Fälle verwenden, in denen X-Ray Sampling nicht verfügbar ist, oder ausschließlich lokale Regeln verwenden.
**Example sampling-rules.json**
```
{
"version": 2,
"rules": [
{
"description": "Player moves.",
"host": "*",
"http_method": "*",
"url_path": "/api/move/*",
"fixed_target": 0,
"rate": 0.05
}
],
"default": {
"fixed_target": 1,
"rate": 0.1
}
}
```
Dieses Beispiel definiert eine benutzerdefinierte Regel und eine Standardregel. Die benutzerdefinierte Regel wendet eine Stichprobenrate von fünf Prozent an, ohne dass eine Mindestanzahl von Anfragen für Pfade verfolgt werden muss. `/api/move/` Die Standardregel verfolgt die erste Anfrage jede Sekunde und 10 Prozent der weiteren Anfragen.
Der Nachteil der lokalen Definition von Regeln besteht darin, dass das feste Ziel von jeder Instanz des Rekorders unabhängig angewendet wird, anstatt vom X-Ray-Dienst verwaltet zu werden. Wenn Sie mehr Hosts bereitstellen, wird die feste Rate vervielfacht, wodurch es schwieriger wird, die Menge der aufgezeichneten Daten zu kontrollieren.
Wenn aktiviert AWS Lambda, können Sie die Samplerate nicht ändern. Wenn Ihre Funktion von einem instrumentierten Dienst aufgerufen wird, werden Aufrufe, die Anfragen generierten, die von diesem Dienst abgetastet wurden, von Lambda aufgezeichnet. Wenn aktives Tracing aktiviert ist und kein Tracing-Header vorhanden ist, trifft Lambda die Stichprobenentscheidung.
Um Backup-Sampling-Regeln zu konfigurieren`xray_recorder.configure`, rufen Sie, wie im folgenden Beispiel gezeigt, auf, wobei entweder *rules* ein Regelwörterbuch oder der absolute Pfad zu einer JSON-Datei mit Sampling-Regeln steht.
```
xray_recorder.configure(sampling_rules=rules)
```
Um nur lokale Regeln zu verwenden, konfigurieren Sie den Recorder mit einer `LocalSampler`.
```
from aws_xray_sdk.core.sampling.local.sampler import LocalSampler
xray_recorder.configure(sampler=LocalSampler())
```
Sie können auch die globale Aufzeichnung so konfigurieren, dass das Sampling deaktiviert und alle eingehenden Anfragen instrumentiert werden.
**Example main.py — Sampling deaktivieren**
```
xray_recorder.configure(sampling=False)
```
## Protokollierung
Das SDK verwendet das in Python integrierte `logging` Modul mit einer `WARNING` Standard-Protokollierungsebene. Erhalten Sie eine Referenz zum Logger für die `aws_xray_sdk`-Klasse und rufen Sie darauf `setLevel` auf, um die verschiedenen Protokollebenen für die Bibliothek und den Rest Ihrer Anwendung zu konfigurieren.
**Example app.py — Protokollierung**
```
logging.basicConfig(level='WARNING')
logging.getLogger('aws_xray_sdk').setLevel(logging.ERROR)
```
Verwenden Sie Debug-Protokolle, um Probleme wie nicht geschlossene Untersegmente zu identifizieren, wenn Sie [Untersegmente manuell generieren](xray-sdk-python-subsegments.md).
## Konfiguration des Recorders im Code
Zusätzliche Einstellungen finden Sie in der `configure`-Methode auf `xray_recorder`.
+ `context_missing`— Auf einstellen, um `LOG_ERROR` zu verhindern, dass Ausnahmen ausgelöst werden, wenn Ihr instrumentierter Code versucht, Daten aufzuzeichnen, obwohl kein Segment geöffnet ist.
+ `daemon_address`— Legt den Host und den Port des X-Ray-Daemon-Listeners fest.
+ `service`— Legen Sie einen Dienstnamen fest, den das SDK für Segmente verwendet.
+ `plugins`— Notieren Sie Informationen über die AWS Ressourcen Ihrer Anwendung.
+ `sampling`— Auf einstellen, `False` um die Probenahme zu deaktivieren.
+ `sampling_rules`— Legen Sie den Pfad der JSON-Datei fest, die Ihre [Sampling-Regeln](#xray-sdk-python-configuration-sampling) enthält.
**Example main.py — Deaktiviert Ausnahmen, die im Kontext fehlen**
```
from aws_xray_sdk.core import xray_recorder
xray_recorder.configure(context_missing='LOG_ERROR')
```
## Konfigurieren des Recorders mit Django
Wenn Sie das Django-Framework verwenden, können Sie die `settings.py`-Datei von Django zum Konfigurieren von Optionen in der globalen Aufzeichnung verwenden.
+ `AUTO_INSTRUMENT`(Nur Django) — Zeichnet Untersegmente für integrierte Datenbank- und Vorlagen-Rendering-Operationen auf.
+ `AWS_XRAY_CONTEXT_MISSING`— Auf einstellen, um `LOG_ERROR` zu vermeiden, dass Ausnahmen ausgelöst werden, wenn Ihr instrumentierter Code versucht, Daten aufzuzeichnen, wenn kein Segment geöffnet ist.
+ `AWS_XRAY_DAEMON_ADDRESS`— Legt den Host und den Port des X-Ray-Daemon-Listeners fest.
+ `AWS_XRAY_TRACING_NAME`— Legen Sie einen Dienstnamen fest, den das SDK für Segmente verwendet.
+ `PLUGINS`— Notieren Sie Informationen über die AWS Ressourcen Ihrer Anwendung.
+ `SAMPLING`— Auf einstellen, `False` um die Probenahme zu deaktivieren.
+ `SAMPLING_RULES`— Legen Sie den Pfad der JSON-Datei fest, die Ihre [Sampling-Regeln](#xray-sdk-python-configuration-sampling) enthält.
Um die Konfiguration des Recorders in `settings.py` zu aktivieren, fügen Sie die Django-Middleware zur Liste der installierten Apps hinzu.
**Example settings.py — Installierte Apps**
```
INSTALLED_APPS = [
...
'django.contrib.sessions',
'aws_xray_sdk.ext.django',
]
```
Konfigurieren Sie die verfügbaren Einstellungen in einem dict-Objekt mit dem Namen `XRAY_RECORDER`.
**Example settings.py — Installierte Apps**
```
XRAY_RECORDER = {
'AUTO_INSTRUMENT': True,
'AWS_XRAY_CONTEXT_MISSING': 'LOG_ERROR',
'AWS_XRAY_DAEMON_ADDRESS': '127.0.0.1:5000',
'AWS_XRAY_TRACING_NAME': 'My application',
'PLUGINS': ('ElasticBeanstalkPlugin', 'EC2Plugin', 'ECSPlugin'),
'SAMPLING': False,
}
```
## Umgebungsvariablen
Sie können Umgebungsvariablen verwenden, um das X-Ray SDK für Python zu konfigurieren. Das SDK unterstützt die folgenden Variablen:
+ `AWS_XRAY_TRACING_NAME`— Legen Sie einen Dienstnamen fest, den das SDK für Segmente verwendet. Überschreibt den Servicenamen, den Sie programmgesteuert festgelegt haben.
+ `AWS_XRAY_SDK_ENABLED`— Wenn auf gesetzt`false`, wird das SDK deaktiviert. Das SDK ist standardmäßig aktiviert, es sei denn, die Umgebungsvariable ist auf „false“ festgelegt.
+ Wenn diese Option deaktiviert ist, generiert die globale Aufzeichnung automatisch Dummy-Segmente und Untersegmente, die nicht an den Daemon gesendet werden, und das automatische Patchen wird deaktiviert. Middlewares werden als Wrapper über der globalen Aufzeichnung geschrieben. Auch alle Generierungen von Segmenten und Untersegmenten über die Middleware werden zu Dummy-Segmenten und Dummy-Untersegmenten.
+ Legen Sie den Wert `AWS_XRAY_SDK_ENABLED` über die Umgebungsvariable oder durch direkte Interaktion mit dem Objekt `global_sdk_config` aus der `aws_xray_sdk`-Bibliothek fest. Einstellungen der Umgebungsvariablen überschreiben diese Interaktionen.
+ `AWS_XRAY_DAEMON_ADDRESS`— Legt den Host und den Port des X-Ray-Daemon-Listeners fest. Standardmäßig verwendet `127.0.0.1:2000` das SDK sowohl Trace-Daten (UDP) als auch Sampling-Daten (TCP). Verwenden Sie diese Variable, wenn Sie den Daemon so konfiguriert haben, dass er [auf einem anderen Port lauscht](xray-daemon-configuration.md) oder wenn er auf einem anderen Host läuft.
**Format**
+ **Derselbe Port** — `address:port`
+ **Verschiedene Anschlüsse** — `tcp:address:port udp:address:port`
+ `AWS_XRAY_CONTEXT_MISSING`— Auf einstellen, `RUNTIME_ERROR` um Ausnahmen auszulösen, wenn Ihr instrumentierter Code versucht, Daten aufzuzeichnen, obwohl kein Segment geöffnet ist.
**Zulässige Werte**
+ `RUNTIME_ERROR`— Löst eine Laufzeitausnahme aus.
+ `LOG_ERROR`— Fehler protokollieren und fortfahren (Standard).
+ `IGNORE_ERROR`— Fehler ignorieren und fortfahren.
Fehler im Zusammenhang mit fehlenden Segmenten oder Untersegmenten können auftreten, wenn Sie versuchen, einen instrumentierten Client in Startcode zu verwenden, der ausgeführt wird, wenn keine Anfrage geöffnet ist, oder in Code, der einen neuen Thread erzeugt.
Umgebungsvariablen überschreiben Werte im Code.
# Nachverfolgung eingehender Anfragen mit dem X-Ray SDK für Python-Middleware
**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).
Wenn Sie die Middleware zu Ihrer Anwendung hinzufügen und einen Segmentnamen konfigurieren, erstellt das X-Ray SDK für Python für jede gesampelte Anfrage ein Segment. Dieses Segment umfasst Dauer, Methode und Status der HTTP-Anforderung. Die zusätzliche Instrumentierung schafft Untersegmente zu diesem Segment.
Das X-Ray SDK für Python unterstützt die folgende Middleware zur Instrumentierung eingehender HTTP-Anfragen:
+ Django
+ Flask
+ Bottle
**Anmerkung**
Für AWS Lambda Funktionen erstellt Lambda für jede abgetastete Anfrage ein Segment. Weitere Informationen finden Sie unter [AWS Lambda und AWS X-Ray](xray-services-lambda.md).
Ein Beispiel [Worker](scorekeep-lambda.md#scorekeep-lambda-worker) für eine in Lambda instrumentierte Python-Funktion finden Sie unter.
Für Skripts oder Python-Anwendungen auf anderen Frameworks können Sie [Segmente manuell erstellen](#xray-sdk-python-middleware-manual).
Jedes Segment hat einen Namen, der Ihre Anwendung in der Service Map identifiziert. Das Segment kann statisch benannt werden, oder Sie können das SDK so konfigurieren, dass es dynamisch auf der Grundlage des Host-Headers in der eingehenden Anfrage benannt wird. Mit der dynamischen Benennung können Sie Traces auf der Grundlage des Domainnamens in der Anfrage gruppieren und einen Standardnamen anwenden, wenn der Name nicht einem erwarteten Muster entspricht (z. B. wenn der Host-Header gefälscht ist).
**Weitergeleitete Anfragen**
Wenn ein Load Balancer oder ein anderer Vermittler eine Anfrage an Ihre Anwendung weiterleitet, nimmt X-Ray die Client-IP aus dem `X-Forwarded-For` Header in der Anfrage und nicht aus der Quell-IP im IP-Paket. Die Client-IP, die für eine weitergeleitete Anfrage aufgezeichnet wird, kann gefälscht sein und sollte daher nicht als vertrauenswürdig eingestuft werden.
Wenn eine Anfrage weitergeleitet wird, legt das SDK ein zusätzliches Feld im Segment fest, um dies anzuzeigen. Wenn das Segment das Feld enthält, das auf `x_forwarded_for` gesetzt ist`true`, wurde die Client-IP aus dem `X-Forwarded-For` Header in der HTTP-Anfrage übernommen.
Die Middleware erzeugt für jede eingehende Anfrage ein Segment mit einem `http`-Block mit folgenden Informationen:
+ **HTTP-Methode** — GET, POST, PUT, DELETE usw.
+ **Client-Adresse** — Die IP-Adresse des Clients, der die Anfrage gesendet hat.
+ **Antwortcode** — Der HTTP-Antwortcode für die abgeschlossene Anfrage.
+ **Timing** — Die Startzeit (als die Anfrage empfangen wurde) und die Endzeit (als die Antwort gesendet wurde).
+ **Benutzeragent** — Der `user-agent` aus der Anfrage.
+ **Länge des Inhalts** — Die Länge `content-length` der Antwort.
**Topics**
+ [Hinzufügen der Middleware zu Ihrer Anwendung (Django)](#xray-sdk-python-adding-middleware-django)
+ [Hinzufügen der Middleware zu Ihrer Anwendung (Flask)](#xray-sdk-python-adding-middleware-flask)
+ [Hinzufügen der Middleware zu Ihrer Anwendung (Bottle)](#xray-sdk-python-adding-middleware-bottle)
+ [Manuelle Instrumentierung von Python-Code](#xray-sdk-python-middleware-manual)
+ [Konfiguration einer Segmentbenennungsstrategie](#xray-sdk-python-middleware-naming)
## Hinzufügen der Middleware zu Ihrer Anwendung (Django)
Fügen Sie die Middleware zur `MIDDLEWARE`-Liste in Ihrer `settings.py`-Datei hinzu. Die X-Ray-Middleware sollte die erste Zeile in Ihrer `settings.py`-Datei darstellen, um sicherzugehen, dass Anfragen, die in anderen Middlewares fehlschlagen, aufgezeichnet werden.
**Example settings.py — X-Ray-SDK für Python-Middleware**
```
MIDDLEWARE = [
'aws_xray_sdk.ext.django.middleware.XRayMiddleware',
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware'
]
```
Fügen Sie die X-Ray SDK Django-App zur `INSTALLED_APPS` Liste in Ihrer `settings.py` Datei hinzu. Dadurch kann der Röntgenrekorder während des Starts Ihrer App konfiguriert werden.
**Example settings.py — X-Ray-SDK für die Python-Django-App**
```
INSTALLED_APPS = [
'aws_xray_sdk.ext.django',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
```
Konfigurieren Sie einen Segmentnamen in Ihrer [`settings.py`-Datei](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-django).
**Example settings.py — Segmentname**
```
XRAY_RECORDER = {
'AWS_XRAY_TRACING_NAME': 'My application',
'PLUGINS': ('EC2Plugin',),
}
```
Dadurch wird der X-Recorder angewiesen, Anfragen, die von Ihrer Django-Anwendung bedient werden, mit der Standard-Abtastrate zu verfolgen. Sie können [den Recorder in Ihrer Django-Einstellungsdatei konfigurieren](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-django), um benutzerdefinierte Samplingregeln anzuwenden oder andere Einstellungen zu ändern.
**Anmerkung**
Da `plugins` sie als Tupel übergeben werden, achten Sie darauf, dass Sie `,` bei der Angabe eines einzelnen Plugins ein abschließendes Zeichen angeben. Beispiel: `plugins = ('EC2Plugin',)`
## Hinzufügen der Middleware zu Ihrer Anwendung (Flask)
Um Ihre Flask-Anwendung zu instrumentieren, konfigurieren Sie zunächst einen Segmentnamen im `xray_recorder`. Verwenden Sie dann die `XRayMiddleware`-Funktion zum Patchen Ihrer Flask-Anwendung im Code.
**Example app.py**
```
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware
app = Flask(__name__)
xray_recorder.configure(service='My application')
XRayMiddleware(app, xray_recorder)
```
Dadurch wird der Röntgenrekorder angewiesen, Anfragen, die von Ihrer Flask-Anwendung bedient werden, mit der Standard-Abtastrate zu verfolgen. Sie können [den Recorder im Code konfigurieren](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-code), um benutzerdefinierte Samplingregeln anzuwenden oder andere Einstellungen zu ändern.
## Hinzufügen der Middleware zu Ihrer Anwendung (Bottle)
Um Ihre Bottle-Anwendung zu instrumentieren, konfigurieren Sie zunächst einen Segmentnamen im `xray_recorder`. Verwenden Sie dann die `XRayMiddleware`-Funktion zum Patchen Ihrer Bottle-Anwendung im Code.
**Example app.py**
```
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.ext.bottle.middleware import XRayMiddleware
app = Bottle()
xray_recorder.configure(service='fallback_name', dynamic_naming='My application')
app.install(XRayMiddleware(xray_recorder))
```
Dadurch wird der Röntgenrekorder angewiesen, Anfragen, die von Ihrer Bottle-Anwendung gesendet wurden, mit der Standard-Abtastrate zu verfolgen. Sie können [den Recorder im Code konfigurieren](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-code), um benutzerdefinierte Samplingregeln anzuwenden oder andere Einstellungen zu ändern.
## Manuelle Instrumentierung von Python-Code
Wenn Sie weder Django noch Flask verwenden, können Sie Segmente manuell erstellen. Sie können für jede eingehende Anfrage ein Segment erstellen oder Segmente rund um gepatchte HTTP- oder AWS SDK-Clients erstellen, um dem Rekorder Kontext für das Hinzufügen von Untersegmenten zu bieten.
**Example main.py — Manuelle Instrumentierung**
```
from aws_xray_sdk.core import xray_recorder
# Start a segment
segment = xray_recorder.begin_segment('segment_name')
# Start a subsegment
subsegment = xray_recorder.begin_subsegment('subsegment_name')
# Add metadata and annotations
segment.put_metadata('key', dict, 'namespace')
subsegment.put_annotation('key', 'value')
# Close the subsegment and segment
xray_recorder.end_subsegment()
xray_recorder.end_segment()
```
## Konfiguration einer Segmentbenennungsstrategie
AWS X-Ray verwendet einen *Dienstnamen*, um Ihre Anwendung zu identifizieren und sie von den anderen Anwendungen, Datenbanken, externen AWS Ressourcen und Ressourcen zu unterscheiden APIs, die Ihre Anwendung verwendet. Wenn das X-Ray SDK Segmente für eingehende Anfragen generiert, zeichnet es den Dienstnamen Ihrer Anwendung im [Namensfeld des Segments auf](xray-api-segmentdocuments.md#api-segmentdocuments-fields).
Das X-Ray SDK kann Segmente nach dem Hostnamen im HTTP-Anforderungsheader benennen. Dieser Header kann jedoch gefälscht sein, was zu unerwarteten Knoten in Ihrer Service Map führen kann. Um zu verhindern, dass das SDK Segmente aufgrund von Anfragen mit gefälschten Host-Headern falsch benennt, müssen Sie einen Standardnamen für eingehende Anfragen angeben.
Wenn Ihre Anwendung Anfragen für mehrere Domänen bearbeitet, können Sie das SDK so konfigurieren, dass es eine dynamische Benennungsstrategie verwendet, um dies in Segmentnamen widerzuspiegeln. Eine dynamische Benennungsstrategie ermöglicht es dem SDK, den Hostnamen für Anfragen zu verwenden, die einem erwarteten Muster entsprechen, und den Standardnamen auf Anfragen anzuwenden, bei denen dies nicht der Fall ist.
Beispielsweise können Sie über eine einzige Anwendung verfügen, die Anfragen an drei Subdomänen — `www.example.com``api.example.com`, und — bedient. `static.example.com` Sie können eine dynamische Benennungsstrategie mit dem Muster verwenden`*.example.com`, um Segmente für jede Subdomain mit einem anderen Namen zu identifizieren, was zu drei Dienstknoten auf der Service-Map führt. Wenn Ihre Anwendung Anfragen mit einem Hostnamen empfängt, der nicht dem Muster entspricht, wird auf der Service Map ein vierter Knoten mit einem von Ihnen angegebenen Fallback-Namen angezeigt.
Wenn Sie denselben Namen für alle Anfragesegmente verwenden möchten, geben Sie bei der Konfiguration des Recorders den Namen Ihrer Anwendung, wie in den [vorherigen Abschnitten](#xray-sdk-python-adding-middleware-django) gezeigt, ein.
Eine dynamische Benennungsstrategie definiert ein Muster, dem Hostnamen entsprechen sollten, sowie einen Standardnamen, der verwendet wird, wenn der Hostname in der HTTP-Anforderung nicht mit diesem Muster übereinstimmt. Zur dynamischen Segmentbenennung fügen Sie die `DYNAMIC_NAMING`-Einstellung zu Ihrer [settings.py](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-django)-Datei hinzu.
**Example settings.py — Dynamische Benennung**
```
XRAY_RECORDER = {
'AUTO_INSTRUMENT': True,
'AWS_XRAY_TRACING_NAME': 'My application',
'DYNAMIC_NAMING': '*.example.com',
'PLUGINS': ('ElasticBeanstalkPlugin', 'EC2Plugin')
}
```
Sie können "\$1" im Muster verwenden, um eine Übereinstimmung mit einer beliebigen Zeichenfolge zu erzielen, oder "?" für die Übereinstimmung mit einem einzelnen Zeichen. Für Flask [konfigurieren Sie den Recorder im Code](xray-sdk-python-configuration.md#xray-sdk-python-middleware-configuration-code).
**Example main.py — Segmentname**
```
from aws_xray_sdk.core import xray_recorder
xray_recorder.configure(service='My application')
xray_recorder.configure(dynamic_naming='*.example.com')
```
**Anmerkung**
Sie können den mit der `AWS_XRAY_TRACING_NAME`-[Umgebungsvariablen](xray-sdk-python-configuration.md#xray-sdk-python-configuration-envvars) in Code definierten standardmäßigen Dienstnamen überschreiben.
# Patchen von Bibliotheken zum Instrumentieren von nachgelagerten Aufrufen
**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 Downstream-Aufrufe zu instrumentieren, verwenden Sie das X-Ray-SDK für Python, um die Bibliotheken zu patchen, die Ihre Anwendung verwendet. Das X-Ray-SDK für Python kann die folgenden Bibliotheken patchen.
**Unterstützte Bibliotheken**
+ `[botocore](https://pypi.python.org/pypi/botocore)`, `[boto3](https://pypi.python.org/pypi/boto3)` — AWS SDK für Python (Boto) Instrumenten-Clients.
+ `[pynamodb](https://pypi.python.org/pypi/pynamodb/)`— Instrumentieren Sie die Version des Amazon DynamoDB-Clients von PynamoDB.
+ `[aiobotocore](https://pypi.python.org/pypi/aiobotocore)`, `[aioboto3](https://pypi.python.org/pypi/aioboto3)` — Instrument [asyncio](https://docs.python.org/3/library/asyncio.html) -integrierte Versionen des SDK für Python-Clients.
+ `[requests](https://pypi.python.org/pypi/requests)`, `[aiohttp](https://pypi.python.org/pypi/aiohttp)` — Instrumentieren Sie HTTP-Clients auf hoher Ebene.
+ `[httplib](https://docs.python.org/2/library/httplib.html)`, [https://docs.python.org/3/library/http.client.html](https://docs.python.org/3/library/http.client.html)— Instrumentieren Sie HTTP-Clients auf niedriger Ebene und die Bibliotheken auf höherer Ebene, die sie verwenden.
+ `[sqlite3](https://docs.python.org/3/library/sqlite3.html)`— SQLite Instrumenten-Clients.
+ `[mysql-connector-python](https://pypi.python.org/pypi/mysql-connector-python)`— Instrumentieren Sie MySQL-Clients.
+ `[pg8000](https://pypi.org/project/pg8000/)`— Instrument Pure-Python PostgreSQL-Schnittstelle.
+ `[psycopg2](https://pypi.org/project/psycopg2/)`— Instrument PostgreSQL-Datenbankadapter.
+ `[pymongo](https://pypi.org/project/pymongo/)`— Instrumentieren Sie MongoDB-Clients.
+ `[pymysql](https://pypi.org/project/PyMySQL/)`— Instrument PyMy SQL-basierte Clients für MySQL und MariaDB.
Wenn Sie eine gepatchte Bibliothek verwenden, erstellt das X-Ray SDK für Python ein Untersegment für den Aufruf und zeichnet Informationen aus der Anfrage und Antwort auf. Für das SDK muss ein Segment zur Verfügung stehen, damit es ein Untersegment aus der SDK-Middleware oder aus AWS Lambda erstellen kann.
**Anmerkung**
Wenn Sie SQLAlchemy ORM verwenden, können Sie Ihre SQL-Abfragen instrumentieren, indem Sie die SDK-Version der SQLAlchemy Sitzungs- und Abfrageklassen importieren. Anweisungen finden [Sie unter SQLAlchemy ORM verwenden](https://github.com/aws/aws-xray-sdk-python/blob/master/README.md#use-sqlalchemy-orm).
Um alle verfügbaren Bibliotheken zu patchen, verwenden Sie die `patch_all`-Funktion in `aws_xray_sdk.core`. Einige Bibliotheken, wie z. B. `httplib` und `urllib`, müssen möglicherweise doppelte Patches durch Aufruf von `patch_all(double_patch=True)` aktivieren.
**Example main.py — Patchen Sie alle unterstützten Bibliotheken**
```
import boto3
import botocore
import requests
import sqlite3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
patch_all()
```
Rufen Sie zum Patchen einer einzelnen Bibliothek `patch` mit einem Tupel des Bibliotheksnamens auf. Um dies zu erreichen, müssen Sie eine einzelne Elementliste bereitstellen.
**Example main.py — Patchen Sie bestimmte Bibliotheken**
```
import boto3
import botocore
import requests
import mysql-connector-python
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch
libraries = (['botocore'])
patch(libraries)
```
**Anmerkung**
In einigen Fällen stimmt der Schlüssel, mit dem Sie eine Bibliothek patchen, nicht mit dem Namen der Bibliothek überein. Einige Schlüssel dienen als Aliase für eine oder mehrere Bibliotheken.
`httplib` – `[httplib](https://docs.python.org/2/library/httplib.html)` und [https://docs.python.org/3/library/http.client.html](https://docs.python.org/3/library/http.client.html)
`mysql` – `[mysql-connector-python](https://pypi.python.org/pypi/mysql-connector-python)`
## Ablaufverfolgungskontext für asynchrone Vorgänge
Für `asyncio` integrierte Bibliotheken oder um [Untersegmente für asynchrone Funktionen zu erstellen](xray-sdk-python-subsegments.md), müssen Sie auch das X-Ray SDK für Python mit einem asynchronen Kontext konfigurieren. Importieren Sie die `AsyncContext` Klasse und übergeben Sie eine Instanz davon an den X-Ray-Recorder.
**Anmerkung**
Bibliotheken für die Unterstützung von Web-Frameworks, wie beispielsweise AIOHTTP, werden nicht über das Modul `aws_xray_sdk.core.patcher` bearbeitet. Sie werden nicht im `patcher`-Katalog unterstützter Bibliotheken angezeigt.
**Example main.py — Patch aioboto3**
```
import asyncio
import aioboto3
import requests
from aws_xray_sdk.core.async_context import AsyncContext
from aws_xray_sdk.core import xray_recorder
xray_recorder.configure(service='my_service', context=AsyncContext())
from aws_xray_sdk.core import patch
libraries = (['aioboto3'])
patch(libraries)
```
# Verfolgen von AWS SDK-Aufrufen mit dem X-Ray SDK für Python
**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).
Wenn Ihre Anwendung Aufrufe tätigt, um Daten AWS-Services zu speichern, in eine Warteschlange zu schreiben oder Benachrichtigungen zu senden, verfolgt das X-Ray SDK für Python die Aufrufe im Downstream in [Untersegmenten](xray-sdk-python-subsegments.md). Verfolgte Ressourcen AWS-Services und Ressourcen, auf die Sie innerhalb dieser Services zugreifen (z. B. ein Amazon S3 S3-Bucket oder eine Amazon SQS SQS-Warteschlange), werden als Downstream-Knoten auf der Trace-Map in der X-Ray-Konsole angezeigt.
Das X-Ray-SDK für Python instrumentiert automatisch alle AWS SDK-Clients, wenn Sie [die `botocore` Bibliothek patchen](xray-sdk-python-patching.md). Einzelne Clients können nicht instrumentiert werden.
Für alle Dienste können Sie den Namen der aufgerufenen API in der X-Ray-Konsole sehen. Für eine Untergruppe von Diensten fügt das X-Ray SDK dem Segment Informationen hinzu, um die Service Map detaillierter zu gestalten.
Wenn Sie beispielsweise einen Aufruf mit einem instrumentierten DynamoDB-Client tätigen, fügt das SDK den Tabellennamen dem Segment für Aufrufe hinzu, die auf eine Tabelle abzielen. In der Konsole wird jede Tabelle als separater Knoten in der Service Map angezeigt, mit einem generischen DynamoDB-Knoten für Aufrufe, die nicht auf eine Tabelle abzielen.
**Example Untersegment für einen Aufruf von DynamoDB zum Speichern eines Elements**
```
{
"id": "24756640c0d0978a",
"start_time": 1.480305974194E9,
"end_time": 1.4803059742E9,
"name": "DynamoDB",
"namespace": "aws",
"http": {
"response": {
"content_length": 60,
"status": 200
}
},
"aws": {
"table_name": "scorekeep-user",
"operation": "UpdateItem",
"request_id": "UBQNSO5AEM8T4FDA4RQDEB94OVTDRVV4K4HIRGVJF66Q9ASUAAJG",
}
}
```
Wenn Sie auf benannte Ressourcen zugreifen, werden durch Aufrufe der folgenden Services weitere Knoten in der Service-Übersicht erstellt. Durch Aufrufe, die keinen bestimmten Ressourcen gelten, wird ein generischer Knoten für den Service erstellt.
+ **Amazon DynamoDB — Tabellenname**
+ **Amazon Simple Storage Service** — Bucket und Schlüsselname
+ **Amazon Simple Queue Service** — Name der Warteschlange
# Verfolgen von Aufrufen an Downstream-HTTP-Webservices mithilfe des X-Ray SDK für Python
**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).
Wenn Ihre Anwendung Microservices oder öffentliches HTTP aufruft APIs, können Sie das X-Ray SDK für Python verwenden, um diese Aufrufe zu instrumentieren und die API als Downstream-Service zum Service Graph hinzuzufügen.
Um HTTP-Clients zu instrumentieren, [patchen Sie die Bibliothek](xray-sdk-python-patching.md), mit der Sie ausgehende Aufrufe durchführen. Wenn Sie `requests` oder den integrierten HTTP-Client von Python verwenden, brauchen Sie nichts weiter zu tun. Bei `aiohttp` müssen Sie zudem den Recorder mit einem [asynchronen Kontext](xray-sdk-python-patching.md#xray-sdk-python-patching-async) konfigurieren.
Wenn Sie die `aiohttp` 3-Client-API verwenden, müssen Sie auch die `ClientSession` mit einer Instance der Nachverfolgungskonfiguration konfigurieren, die vom SDK bereitgestellt wird.
**Example [`aiohttp` 3 Client-API](https://github.com/aws/aws-xray-sdk-python#trace-aiohttp-client-requests)**
```
from aws_xray_sdk.ext.aiohttp.client import aws_xray_trace_config
async def foo():
trace_config = aws_xray_trace_config()
async with ClientSession(loop=loop, trace_configs=[trace_config]) as session:
async with session.get(url) as resp
await resp.read()
```
Wenn Sie einen Aufruf einer Downstream-Web-API instrumentieren, zeichnet das X-Ray-SDK für Python ein Untersegment auf, das Informationen über die HTTP-Anfrage und -Antwort enthält. X-Ray verwendet das Untersegment, um ein abgeleitetes Segment für die Remote-API zu generieren.
**Example Untersegment für einen nachgelagerten HTTP-Aufruf**
```
{
"id": "004f72be19cddc2a",
"start_time": 1484786387.131,
"end_time": 1484786387.501,
"name": "names.example.com",
"namespace": "remote",
"http": {
"request": {
"method": "GET",
"url": "https://names.example.com/"
},
"response": {
"content_length": -1,
"status": 200
}
}
}
```
**Example Abgeleitetes Segment für einen nachgelagerten HTTP-Anruf**
```
{
"id": "168416dc2ea97781",
"name": "names.example.com",
"trace_id": "1-62be1272-1b71c4274f39f122afa64eab",
"start_time": 1484786387.131,
"end_time": 1484786387.501,
"parent_id": "004f72be19cddc2a",
"http": {
"request": {
"method": "GET",
"url": "https://names.example.com/"
},
"response": {
"content_length": -1,
"status": 200
}
},
"inferred": true
}
```
# Generieren von benutzerdefinierten Untersegmenten mit dem X-Ray SDK für Python
**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).
Untersegmente erweitern das [Segment](xray-concepts.md#xray-concepts-segments) eines Traces um Details über die Arbeit, die zur Bearbeitung einer Anfrage geleistet wurde. Jedes Mal, wenn Sie einen Anruf mit einem instrumentierten Client tätigen, zeichnet das X-Ray-SDK die in einem Untersegment generierten Informationen auf. Sie können zusätzliche Untersegmente erstellen, um andere Untersegmente zu gruppieren, die Leistung eines Codeabschnitts zu messen oder Anmerkungen und Metadaten aufzuzeichnen.
Um Untersegmente zu verwalten, verwenden Sie die Methoden `begin_subsegment` und `end_subsegment`.
**Example main.py — Benutzerdefiniertes Untersegment**
```
from aws_xray_sdk.core import xray_recorder
subsegment = xray_recorder.begin_subsegment('annotations')
subsegment.put_annotation('id', 12345)
xray_recorder.end_subsegment()
```
Um ein Untersegment für eine synchrone Funktion zu erstellen, verwenden Sie den `@xray_recorder.capture`-Decorator. Sie können einen Namen für das Untersegment an die Erfassungsfunktion übergeben oder diesen weglassen und den Funktionsnamen verwenden.
**Example main.py — Funktionsuntersegment**
```
from aws_xray_sdk.core import xray_recorder
@xray_recorder.capture('## create_user')
def create_user():
...
```
Verwenden Sie bei einer asynchronen Funktion den `@xray_recorder.capture_async`-Decorator und übergeben Sie einen asynchronen Kontext an den Recorder.
**Example main.py — Untersegment einer asynchronen Funktion**
```
from aws_xray_sdk.core.async_context import AsyncContext
from aws_xray_sdk.core import xray_recorder
xray_recorder.configure(service='my_service', context=AsyncContext())
@xray_recorder.capture_async('## create_user')
async def create_user():
...
async def main():
await myfunc()
```
Wenn Sie ein Untersegment innerhalb eines Segments oder eines anderen Untersegments erstellen, generiert das X-Ray SDK für Python eine ID dafür und zeichnet die Start- und Endzeit auf.
**Example Untersegment mit Metadaten**
```
"subsegments": [{
"id": "6f1605cd8a07cb70",
"start_time": 1.480305974194E9,
"end_time": 1.4803059742E9,
"name": "Custom subsegment for UserModel.saveUser function",
"metadata": {
"debug": {
"test": "Metadata string from UserModel.saveUser"
}
},
```
# Hinzufügen von Anmerkungen und Metadaten zu Segmenten mit dem X-Ray SDK für Python
**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 zusätzliche Informationen über Anfragen, die Umgebung oder Ihre Anwendung mit Anmerkungen und Metadaten aufzeichnen. Sie können Anmerkungen und Metadaten zu den Segmenten hinzufügen, die das X-Ray SDK erstellt, oder zu benutzerdefinierten Untersegmenten, die Sie erstellen.
**Anmerkungen** sind Schlüssel-Wert-Paare mit Zeichenfolgen-, Zahlen- oder booleschen Werten. [Anmerkungen sind für die Verwendung mit Filterausdrücken indexiert.](xray-console-filters.md) Berücksichtigen Sie Anmerkungen, um Daten zur Gruppierung von Ablaufverfolgungen in der Konsole zu verwenden, oder wenn Sie die [https://docs.aws.amazon.com/xray/latest/api/API_GetTraceSummaries.html](https://docs.aws.amazon.com/xray/latest/api/API_GetTraceSummaries.html)-API aufrufen.
**Metadaten** sind Schlüssel-Wert-Paare, die Werte beliebigen Typs enthalten können, einschließlich Objekte und Listen, aber nicht für die Verwendung mit Filterausdrücken indexiert sind. Verwenden Sie Metadaten, um zusätzliche Daten aufzuzeichnen, die Sie im Trace speichern möchten, aber nicht für die Suche verwenden müssen.
Zusätzlich zu Anmerkungen und Metadaten können Sie auch [Benutzer-ID-Zeichenfolgen](#xray-sdk-python-segment-userid) in Segmenten aufzeichnen. Benutzer IDs werden in einem separaten Feld in Segmenten aufgezeichnet und für die Verwendung bei der Suche indexiert.
**Topics**
+ [Anmerkungen mit dem X-Ray SDK für Python aufnehmen](#xray-sdk-python-segment-annotations)
+ [Metadaten mit dem X-Ray SDK für Python aufzeichnen](#xray-sdk-python-segment-metadata)
+ [Benutzer IDs mit dem X-Ray SDK für Python aufzeichnen](#xray-sdk-python-segment-userid)
## Anmerkungen mit dem X-Ray SDK für Python aufnehmen
Verwenden Sie Anmerkungen, um Informationen zu Segmenten oder Untersegmenten, die zur Suche indiziert werden sollten, aufzuzeichnen.
**Anmerkung zu Anforderungen**
+ **Schlüssel** — Der Schlüssel für eine X-Ray-Anmerkung kann bis zu 500 alphanumerische Zeichen enthalten. Sie können keine anderen Leerzeichen oder Symbole als einen Punkt oder Punkt (.) verwenden
+ **Werte** — Der Wert für eine X-Ray-Anmerkung kann bis zu 1.000 Unicode-Zeichen enthalten.
+ Die Anzahl der **Anmerkungen** — Sie können bis zu 50 Anmerkungen pro Spur verwenden.
**So zeichnen Sie Anmerkungen auf**
1. Eine Referenz des aktuellen Segments oder Untersegments finden Sie unter `xray_recorder`.
```
from aws_xray_sdk.core import xray_recorder
...
document = xray_recorder.current_segment()
```
oder
```
from aws_xray_sdk.core import xray_recorder
...
document = xray_recorder.current_subsegment()
```
1. Rufen Sie `put_annotation` mit einem Aktivierungsschlüssel und einem booleschen Wert oder einem Zeichenfolgenwert auf.
```
document.put_annotation("mykey", "my value");
```
Das folgende Beispiel zeigt, wie Sie `putAnnotation` mit einem String-Schlüssel aufrufen, der einen Punkt und einen booleschen Wert, eine Zahl oder einen String-Wert enthält.
```
document.putAnnotation("testkey.test", "my value");
```
Alternativ können Sie auch die `put_annotation`-Methode im `xray_recorder` verwenden. Mit dieser Methode werden Anmerkungen zum aktuellen Untersegment oder zum Segment aufgezeichnet, wenn kein Untersegment geöffnet ist.
```
xray_recorder.put_annotation("mykey", "my value");
```
Das SDK zeichnet Anmerkungen als Schlüssel-Wert-Paare in einem `annotations`-Objekt im Segmentdokument auf. Wenn `put_annotation` zweimal mit demselben Schlüssel aufgerufen wird, werden zuvor aufgezeichnete Werte im gleichen Segment oder Untersegment überschrieben.
Nutzen Sie das `annotation[key]`-Schlüsselwort in einem [Filterausdruck](xray-console-filters.md), um Ablaufverfolgungen durch Anmerkungen mit bestimmten Werten zu finden.
## Metadaten mit dem X-Ray SDK für Python aufzeichnen
**Warnung**
Fügen Sie dem X-Ray SDK für Python keine Objekte mit Zirkelverweisen als Metadatenwerte hinzu. Diese Objekte können nicht in JSON serialisiert werden und können Endlosschleifen im SDK erzeugen. Vermeiden Sie außerdem, große, komplexe Objekte als Metadaten hinzuzufügen, um Leistungsprobleme zu vermeiden.
Verwenden Sie Metadaten, um Segment- oder Untersegmentinformationen aufzuzeichnen, die nicht zur Suche indiziert werden müssen. Metadatenwerte sind Zeichenfolgen, Zahlen, boolesche Werte oder andere Objekte, die in Form eines JSON-Objekts oder eines Arrays angeordnet sein können.
**So zeichnen Sie Metadaten auf**
1. Eine Referenz des aktuellen Segments oder Untersegments finden Sie unter `xray_recorder`.
```
from aws_xray_sdk.core import xray_recorder
...
document = xray_recorder.current_segment()
```
oder
```
from aws_xray_sdk.core import xray_recorder
...
document = xray_recorder.current_subsegment()
```
1. Rufen Sie `put_metadata` mit einem Zeichenfolgenschlüssel, einem booleschen Wert, einer Zahl, einer Zeichenfolge oder einem Objektwert und einem Zeichenfolgen-Namespace auf.
```
document.put_metadata("my key", "my value", "my namespace");
```
oder
Rufen Sie `put_metadata` nur mit einem Aktivierungsschlüssel und einem Wert auf.
```
document.put_metadata("my key", "my value");
```
Alternativ können Sie auch die `put_metadata`-Methode im `xray_recorder` verwenden. Mit dieser Methode werden Metadaten zum aktuellen Untersegment oder zum Segment aufgezeichnet, wenn kein Untersegment geöffnet ist.
```
xray_recorder.put_metadata("my key", "my value");
```
Wenn Sie keinen Namespace angeben, verwendet SDK `default`. Wenn `put_metadata` zweimal mit demselben Schlüssel aufgerufen wird, werden zuvor aufgezeichnete Werte im gleichen Segment oder Untersegment überschrieben.
## Benutzer IDs mit dem X-Ray SDK für Python aufzeichnen
Zeichnen Sie Segmente von Benutzern IDs auf Anfrage auf, um den Benutzer zu identifizieren, der die Anfrage gesendet hat.
**Um den Benutzer aufzuzeichnen IDs**
1. Eine Referenz des aktuellen Segments finden Sie unter `xray_recorder`.
```
from aws_xray_sdk.core import xray_recorder
...
document = xray_recorder.current_segment()
```
1. Rufen Sie `setUser` mit einer Zeichenfolgen-ID des Benutzers auf, der die Anforderung gesendet hat.
```
document.set_user("U12345");
```
Sie können `set_user` in Ihrem Controller aufrufen, um die Benutzer-ID aufzuzeichnen, sobald die Anwendung mit der Bearbeitung einer Anfrage beginnt.
Nutzen Sie das `user`-Schlüsselwort in einem [Filterausdruck](xray-console-filters.md), um Ablaufverfolgungen einer Benutzer-ID zu finden.
# Instrumentieren von in serverlosen Umgebungen bereitgestellten Web-Frameworks
**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).
Das AWS X-Ray SDK für Python unterstützt die Instrumentierung von Web-Frameworks, die in serverlosen Anwendungen eingesetzt werden. Die Cloud ist von Natur aus serverlos und dies bietet Ihnen die Möglichkeit, immer mehr Ihrer betrieblichen Verantwortung auf AWS zu verlagern. Der unschätzbare Nutzen für Sie sind mehr Agilität und Innovation.
Eine serverlose Architektur ist ein Softwareanwendungsmodell, mit dem Sie Anwendungen und Services entwickeln und ausführen können, ohne über Server nachdenken zu müssen. Für Sie verringern sich die Aufgaben der Infrastrukturverwaltung wie die Bereitstellung von Servern oder Clustern, Patching, Betriebssystemwartung und Kapazitätsbereitstellung. Sie können serverlose Lösungen für praktisch jeden Anwendungstyp oder Backend-Service erstellen und alles, was zum Ausführen und Skalieren Ihrer Anwendung mit hoher Verfügbarkeit erforderlich ist, wird für Sie durchgeführt.
Dieses Tutorial zeigt Ihnen, wie Sie ein Web-Framework wie Flask oder Django, das in einer serverlosen Umgebung bereitgestellt wird, automatisch AWS X-Ray instrumentieren. Die X-Ray-Instrumentierung der Anwendung ermöglicht es Ihnen, alle getätigten Downstream-Aufrufe, angefangen von Amazon API Gateway über Ihre AWS Lambda Funktion, bis hin zu den ausgehenden Aufrufen Ihrer Anwendung zu sehen.
Das X-Ray-SDK für Python unterstützt die folgenden Python-Anwendungsframeworks:
+ Flask-Version 0.8 oder höher
+ Django-Version 1.0 oder höher
In diesem Tutorial wird eine serverlose Beispielanwendung entwickelt, die auf Lambda bereitgestellt und von API Gateway aufgerufen wird. In diesem Tutorial wird Zappa verwendet, um die Anwendung automatisch auf Lambda bereitzustellen und den API-Gateway-Endpunkt zu konfigurieren.
## Voraussetzungen
+ [Zappa](https://github.com/Miserlou/Zappa)
+ [Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) — Version 2.7 oder 3.6.
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)— Stellen Sie sicher, dass Ihr Konto mit dem Konto konfiguriert AWS CLI ist und AWS-Region in dem Sie Ihre Anwendung bereitstellen werden.
+ [Pip](https://pypi.org/project/pip/)
+ [Virtualenv](https://virtualenv.pypa.io/en/latest/)
## Schritt 1: Erstellen einer Umgebung
In diesem Schritt erstellen Sie eine virtuelle Umgebung mit `virtualenv` zum Hosten einer Anwendung.
1. Erstellen Sie mit dem AWS CLI ein Verzeichnis für die Anwendung. Wechseln Sie anschließend zum neuen Verzeichnis.
```
mkdir serverless_application
cd serverless_application
```
1. Erstellen Sie dann eine virtuelle Umgebung in Ihrem neuen Verzeichnis. Aktivieren Sie sie mit dem folgenden Befehl.
```
# Create our virtual environment
virtualenv serverless_env
# Activate it
source serverless_env/bin/activate
```
1. Installieren Sie X-Ray, Flask, Zappa und die Requests-Bibliothek in Ihrer Umgebung.
```
# Install X-Ray, Flask, Zappa, and Requests into your environment
pip install aws-xray-sdk flask zappa requests
```
1. Fügen Sie Anwendungscode zum Verzeichnis `serverless_application` hinzu. In diesem Beispiel bauen wir auf dem Flask-Beispiel [Hallo Welt](https://flask.palletsprojects.com/en/3.0.x/quickstart/) auf.
Erstellen Sie in dem Verzeichnis `serverless_application` eine Datei namens `my_app.py`. Fügen Sie anschließend mit einem Texteditor die folgenden Befehle hinzu. Diese Anwendung instrumentiert die Anfragebibliothek, führt Patches für die Middleware der Flask-Anwendung aus und öffnet den Endpunkt `'/'`.
```
# Import the X-Ray modules
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware
from aws_xray_sdk.core import patcher, xray_recorder
from flask import Flask
import requests
# Patch the requests module to enable automatic instrumentation
patcher.patch(('requests',))
app = Flask(__name__)
# Configure the X-Ray recorder to generate segments with our service name
xray_recorder.configure(service='My First Serverless App')
# Instrument the Flask application
XRayMiddleware(app, xray_recorder)
@app.route('/')
def hello_world():
resp = requests.get("https://aws.amazon.com")
return 'Hello, World: %s' % resp.url
```
## Schritt 2: Erstellen und Bereitstellen einer Zappa-Umgebung
In diesem Schritt verwenden Sie Zappa, um automatisch einen API-Gateway-Endpunkt zu konfigurieren und ihn dann auf Lambda bereitzustellen.
1. Initialisieren Sie Zappa über das Verzeichnis `serverless_application`. In diesem Beispiel verwenden wir die Standardeinstellungen. Wenn Sie jedoch über individuelle Voreinstellungen verfügen, zeigt Zappa Anleitungen für die Konfiguration an.
```
zappa init
```
```
What do you want to call this environment (default 'dev'): dev
...
What do you want to call your bucket? (default 'zappa-*******'): zappa-*******
...
...
It looks like this is a Flask application.
What's the modular path to your app's function?
This will likely be something like 'your_module.app'.
We discovered: my_app.app
Where is your app's function? (default 'my_app.app'): my_app.app
...
Would you like to deploy this application globally? (default 'n') [y/n/(p)rimary]: n
```
1. X-Ray aktivieren. Öffnen Sie die Datei `zappa_settings.json` und stellen Sie sicher, dass sie dem Beispiel ähnelt.
```
{
"dev": {
"app_function": "my_app.app",
"aws_region": "us-west-2",
"profile_name": "default",
"project_name": "serverless-exam",
"runtime": "python2.7",
"s3_bucket": "zappa-*********"
}
}
```
1. Fügen Sie `"xray_tracing": true` als Eintrag zur Konfigurationsdatei hinzu.
```
{
"dev": {
"app_function": "my_app.app",
"aws_region": "us-west-2",
"profile_name": "default",
"project_name": "serverless-exam",
"runtime": "python2.7",
"s3_bucket": "zappa-*********",
"xray_tracing": true
}
}
```
1. Stellen Sie die Anwendung bereit. Dadurch wird der API-Gateway-Endpunkt automatisch konfiguriert und Ihr Code auf Lambda hochgeladen.
```
zappa deploy
```
```
...
Deploying API Gateway..
Deployment complete!: https://**********.execute-api.us-west-2.amazonaws.com/dev
```
## Schritt 3: X-Ray Tracing für API Gateway aktivieren
In diesem Schritt interagieren Sie mit der API Gateway Gateway-Konsole, um das X-Ray-Tracing zu aktivieren.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. Suchen Sie Ihre neu generierte API. Sie sollte in etwa so aussehen: `serverless-exam-dev`.
1. Wählen Sie **Stages**.
1. Wählen Sie den Namen der Bereitstellungsstufe. Der Standardwert ist `dev`.
1. Wählen Sie auf der Registerkarte **Logs/Tracing (Protokolle/Nachverfolgung)** die Option **Enable X-Ray Tracing (X-Ray-Tracing aktivieren)** aus.
1. Wählen Sie **Save Changes**.
1. Rufen Sie den Endpunkt in Ihrem Browser auf. Wenn Sie die Beispielanwendung `Hello World` verwendet haben, sollte Folgendes angezeigt werden.
```
"Hello, World: https://aws.amazon.com/"
```
## Schritt 4: Anzeigen der erstellten Nachverfolgung
In diesem Schritt interagieren Sie mit der X-Ray-Konsole, um den von der Beispielanwendung erstellten Trace anzuzeigen. Einen detaillierteren Leitfaden für die Analyse von Nachverfolgungen finden Sie unter [Anzeigen der Service-Übersicht](https://docs.aws.amazon.com/xray/latest/devguide/xray-console.html#xray-console-servicemap).
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die X-Ray-Konsole zu [https://console.aws.amazon.com/xray/Hause](https://console.aws.amazon.com/xray/home).
1. Zeigen Sie Segmente an, die von API Gateway, der Lambda-Funktion und dem Lambda-Container generiert wurden.
1. Sehen Sie sich unter dem Lambda-Funktionssegment ein Untersegment mit dem Namen an. `My First Serverless App` Dahinter folgt ein zweites Untersegment mit dem Namen `https://aws.amazon.com`.
1. Während der Initialisierung generiert Lambda möglicherweise auch ein drittes Untersegment mit dem Namen. `initialization`
![\[Ansicht des Trace-Segments\]](http://docs.aws.amazon.com/de_de/xray/latest/devguide/images/serverless-traceView.png)
![\[Ansicht der Service-Grafik\]](http://docs.aws.amazon.com/de_de/xray/latest/devguide/images/serverless-serviceView.png)
## Schritt 5: Bereinigen
Sie sollten Ressourcen, die Sie nicht mehr verwenden, stets beenden, um unerwartete Kosten zu vermeiden. Wie in diesem Tutorial gezeigt, lässt sich die serverlose erneute Bereitstellung mit Tools wie Zappa optimieren.
Um Ihre Anwendung aus Lambda, API Gateway und Amazon S3 zu entfernen, führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus, indem Sie den AWS CLI verwenden.
```
zappa undeploy dev
```
## Nächste Schritte
Fügen Sie Ihrer Anwendung weitere Funktionen hinzu, indem Sie AWS Clients hinzufügen und sie mit X-Ray instrumentieren. Weitere Informationen zu den Optionen für serverloses Computing finden Sie unter [Serverless](https://aws.amazon.com/serverless) on. AWS