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.
# 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`
## 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