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.
# Erstellen von Lambda-Funktionen mit Python
Sie können Python-Code in AWS Lambda ausführen. Lambda bietet [Laufzeiten](lambda-runtimes.md) für Python, die Ihren Code ausführen, um Ereignisse zu verarbeiten. Ihr Code wird in einer Umgebung ausgeführt, die das SDK for Python (Boto3) enthält, mit Anmeldeinformationen von einer AWS Identity and Access Management (IAM-) Rolle, die Sie verwalten. Weitere Informationen zu den SDK-Versionen, die in den Laufzeiten von Python enthalten sind, finden Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](#python-sdk-included).
Lambda unterstützt die folgenden Python-Laufzeiten.
| Name | ID | Betriebssystem | Datum der Veraltung | Blockfunktion erstellen | Blockfunktion aktualisieren |
| --- | --- | --- | --- | --- | --- |
| Python 3.14 | `python3.14` | Amazon Linux 2023 | 30. Juni 2029 | 31. Juli 2029 | 31. August 2029 |
| Python 3.13 | `python3.13` | Amazon Linux 2023 | 30. Juni 2029 | 31. Juli 2029 | 31. August 2029 |
| Python 3.12 | `python3.12` | Amazon Linux 2023 | 31. Oktober 2028 | 30. November 2028 | 10. Januar 2029 |
| Python 3.11 | `python3.11` | Amazon Linux 2 | 30. Juni 2027 | 31. Juli 2027 | 31. August 2027 |
| Python 3.10 | `python3.10` | Amazon Linux 2 | 31. Oktober 2026 | 30. November 2026 | 15. Januar 2027 |
**So erstellen Sie eine Python-Funktion**
1. Öffnen Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda).
1. Wählen Sie **Funktion erstellen**.
1. Konfigurieren Sie die folgenden Einstellungen:
+ **Funktionsname**: Geben Sie einen Namen für die Funktion ein.
+ **Runtime**: Wähle **Python 3.14**.
1. Wählen Sie **Funktion erstellen**.
Die Konsole erstellt eine Lambda-Funktion mit einer einzigen Quelldatei mit dem Namen `lambda_function`. Mit dem integrierten Code-Editor können Sie diese Datei bearbeiten und weitere Dateien hinzufügen. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren. Um Ihren Code auszuführen, wählen Sie anschließend im Abschnitt **TESTEREIGNISSE** die Option **Testereignis erstellen** aus.
Ihre Lambda-Funktion wird mit einer CloudWatch Logs-Protokollgruppe geliefert. Die Funktionslaufzeit sendet Details zu jedem Aufruf an CloudWatch Logs. Es leitet alle [Protokolle weiter, die Ihre Funktion während des Aufrufs ausgibt](python-logging.md). Wenn Ihre Funktion einen Fehler zurückgibt, formatiert Lambda den Fehler und gibt ihn an den Aufrufer zurück.
**Topics**
+ [SDK-Versionen, die zur Laufzeit enthalten sind](#python-sdk-included)
+ [Deaktivierte Python-Funktionen](#python-disabled-features)
+ [Reaktionsformat](#python-response-format)
+ [Ordnungsgemäßes Herunterfahren von Erweiterungen](#python-graceful-shutdown)
+ [Lambda-Funktionshandler in Python definieren](python-handler.md)
+ [Arbeiten mit ZIP-Dateiarchiven und Python-Lambda-Funktionen](python-package.md)
+ [Bereitstellen von Python-Lambda-Funktionen mit Container-Images](python-image.md)
+ [Arbeiten mit Ebenen für Python Lambda-Funktionen](python-layers.md)
+ [Verwenden des Lambda-Kontextobjekts zum Abrufen von Python-Funktionsinformationen](python-context.md)
+ [Python-Lambda-Funktionen protokollieren und überwachen](python-logging.md)
+ [AWS Lambda-Funktionstests in Python](python-testing.md)
+ [Instrumentierung von Python-Code in AWS Lambda](python-tracing.md)
## SDK-Versionen, die zur Laufzeit enthalten sind
Die Version des AWS SDK, die in der Python-Laufzeit enthalten ist, hängt von der Laufzeitversion und Ihrer ab AWS-Region. Um die Version des SDK zu finden, die in der von Ihnen verwendeten Laufzeit enthalten ist, erstellen Sie eine Lambda-Funktion mit dem folgenden Code.
```
import boto3
import botocore
def lambda_handler(event, context):
print(f'boto3 version: {boto3.__version__}')
print(f'botocore version: {botocore.__version__}')
```
## Deaktivierte Python-Funktionen
In der folgenden Tabelle sind Python-Funktionen aufgeführt, die in den von Lambda verwalteten Laufzeiten und Container-Basis-Images für Python deaktiviert sind. Diese Funktionen müssen aktiviert werden, wenn die ausführbare Python-Runtime-Datei kompiliert wird. Sie können nicht mithilfe eines Ausführungszeitflags aktiviert werden. Um diese Funktionen in Lambda zu verwenden, können Sie Ihren eigenen Python-Runtime-Build mit aktivierten Funktionen bereitstellen, indem Sie ein [Container-Image](python-image.md#python-image-clients) oder eine [benutzerdefinierte Laufzeit](runtimes-custom.md) verwenden.
| Python-Funktion | Betroffene Python-Versionen | Status |
| --- | --- | --- |
| Just-in-Time (JIT) -Compiler | Python 3.13 und höher | Der JIT-Compiler ist experimentell und wird für Produktionsworkloads nicht empfohlen. Es ist daher in den Lambda-Python-Laufzeiten deaktiviert. |
| Kostenloses Threading | Python 3.13 und höher | Kostenloses Threading (Option zum Deaktivieren der globalen Interpretersperre) ist in Lambda-Python-Builds deaktiviert, da sich dies auf die Leistung von Single-Thread-Code auswirkt. |
## Reaktionsformat
In Python 3.12 und späteren Python-Laufzeiten geben Funktionen Unicode-Zeichen als Teil ihrer JSON-Antwort zurück. Frühere Python-Laufzeiten geben Escape-Sequenzen für Unicode-Zeichen in Antworten zurück. Wenn Sie beispielsweise in Python 3.11 eine Unicode-Zeichenfolge wie "こんにちは" zurückgeben, werden die Unicode-Zeichen mit Ecape-Zeichen versehen und es wird "\$1u3053\$1u3093\$1u306b\$1u3061\$1u306f" zurückgegeben. Die Python-3.12-Laufzeit gibt das Original "こんにちは" zurück.
Durch die Verwendung von Unicode-Antworten wird die Größe von Lambda-Antworten reduziert, sodass größere Antworten einfacher in die maximale Nutzlastgröße von 6 MB für synchrone Funktionen passen können. Im vorherigen Beispiel hat die Escaped-Version 32 Byte – die Unicode-Zeichenfolge hat 17 Byte.
Wenn Sie auf Python 3.12 oder spätere Python-Laufzeiten aktualisieren, müssen Sie möglicherweise Ihren Code anpassen, um das neue Antwortformat zu berücksichtigen. Wenn der Aufrufer Unicode in Escape-Zeichen erwartet, müssen Sie entweder der zurückgebenden Funktion Code hinzufügen, um den Unicode manuell mit Escape-Zeichen zu versehen, oder den Aufrufer so anpassen, dass er die Unicode-Rückgabe verarbeitet.
## Ordnungsgemäßes Herunterfahren von Erweiterungen
Python 3.12 und neuere Python-Laufzeiten bieten verbesserte Funktionen zum ordnungsgemäßen Herunterfahren von Funktionen mit [externen Erweiterungen](lambda-extensions.md). Wenn Lambda eine Ausführungsumgebung beendet, sendet es ein `SIGTERM`-Signal an die Laufzeitumgebung und dann ein `SHUTDOWN`-Ereignis an jede registrierte externe Erweiterung. Sie können das `SIGTERM`-Signal in Ihrer Lambda-Funktion abfangen und Ressourcen wie Datenbankverbindungen, die von der Funktion erstellt wurden, bereinigen.
Weitere Informationen zum Lebenszyklus der Ausführungsumgebung finden Sie unter [Verständnis des Lebenszyklus der Lambda-Ausführungsumgebung](lambda-runtime-environment.md). [Beispiele für die Verwendung von Graceful Shutdown mit Erweiterungen finden Sie im Samples-Repository.AWS GitHub ](https://github.com/aws-samples/graceful-shutdown-with-aws-lambda)
# Lambda-Funktionshandler in Python definieren
Der Lambda-Funktions*handler* ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt.
Auf dieser Seite wird beschrieben, wie Sie mit Lambda-Funktionshandlern in Python arbeiten, einschließlich Namenskonventionen, gültigen Handler-Signaturen und Best Practices für Code. Diese Seite enthält auch ein Beispiel für eine Python-Lambda-Funktion, die Informationen über einen Auftrag aufnimmt, eine Textdatei als Quittung erstellt und diese Datei in einem Bucket von Amazon Simple Storage Service (Amazon S3) platziert.
**Topics**
+ [Beispiel für Python-Lambda-Funktionscode](#python-handler-example)
+ [Namenskonventionen für Handler](#python-handler-naming)
+ [Verwenden des Lambda-Ereignisobjekts](#python-handler-event)
+ [Zugreifen auf und Verwenden des Lambda-Kontextobjekts](#python-handler-context)
+ [Gültige Handler-Signaturen für Python-Handler](#python-handler-signature)
+ [Rückgabe eines Wertes](#python-handler-return)
+ [Verwenden Sie das AWS SDK für Python (Boto3) in Ihrem Handler](#python-handler-sdk)
+ [Zugriff auf Umgebungsvariablen](#python-handler-env-vars)
+ [Bewährte Codemethoden für Python-Lambda-Funktionen](#python-handler-best-practices)
## Beispiel für Python-Lambda-Funktionscode
Das folgende Beispiel für einen Python-Lambda-Funktionscode nimmt Informationen über eine Bestellung auf, erstellt eine Textdateiquittung und platziert diese Datei in einem Amazon-S3-Bucket:
**Example Python-Lambda-Funktion**
```
import json
import os
import logging
import boto3
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
# Initialize the logger
logger = logging.getLogger()
logger.setLevel("INFO")
def upload_receipt_to_s3(bucket_name, key, receipt_content):
"""Helper function to upload receipt to S3"""
try:
s3_client.put_object(
Bucket=bucket_name,
Key=key,
Body=receipt_content
)
except Exception as e:
logger.error(f"Failed to upload receipt to S3: {str(e)}")
raise
def lambda_handler(event, context):
"""
Main Lambda handler function
Parameters:
event: Dict containing the Lambda function event data
context: Lambda runtime context
Returns:
Dict containing status message
"""
try:
# Parse the input event
order_id = event['Order_id']
amount = event['Amount']
item = event['Item']
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
if not bucket_name:
raise ValueError("Missing required environment variable RECEIPT_BUCKET")
# Create the receipt content and key destination
receipt_content = (
f"OrderID: {order_id}\n"
f"Amount: ${amount}\n"
f"Item: {item}"
)
key = f"receipts/{order_id}.txt"
# Upload the receipt to S3
upload_receipt_to_s3(bucket_name, key, receipt_content)
logger.info(f"Successfully processed order {order_id} and stored receipt in S3 bucket {bucket_name}")
return {
"statusCode": 200,
"message": "Receipt processed successfully"
}
except Exception as e:
logger.error(f"Error processing order: {str(e)}")
raise
```
Diese -Datei enthält die folgenden Abschnitte des Codes:
+ `import`-Block: Verwenden Sie diesen Block, um Bibliotheken einzubinden, die Ihre Lambda-Funktion benötigt.
+ Globale Initialisierung von SDK-Client und Logger: Durch das Einfügen von Initialisierungscode außerhalb des Handlers wird die Wiederverwendung der [Ausführungsumgebung](lambda-runtime-environment.md) genutzt, um die Leistung Ihrer Funktion zu verbessern. Weitere Informationen hierzu finden Sie unter [Bewährte Codemethoden für Python-Lambda-Funktionen](#python-handler-best-practices).
+ `def upload_receipt_to_s3(bucket_name, key, receipt_content):`: Dies ist eine Hilfsfunktion, die von der `lambda_handler`-Hauptfunktion aufgerufen wird.
+ `def lambda_handler(event, context):`: Dies ist die **Haupthandler-Funktion** für Ihren Code, die Ihre Hauptanwendungslogik enthält. Wenn Lambda Ihren Funktionshandler aufruft, übergibt die [Lambda-Laufzeit](concepts-basics.md#gettingstarted-concepts-runtime) zwei Argumente an die Funktion: das [Ereignisobjekt](#python-handler-event), das Daten für die Verarbeitung durch Ihre Funktion enthält, und das [Kontextobjekt](#python-handler-context), das Informationen über den Funktionsaufruf enthält.
## Namenskonventionen für Handler
Der zum Zeitpunkt der Erstellung einer Lambda-Funktion definierte Funktionshandlername wird abgeleitet von:
+ dem Namen der Datei, in der sich die Lambda-Handler-Funktion befindet.
+ dem Namen der Python-Handler-Funktion.
Wenn die Datei im obigen Beispiel `lambda_function.py` heißt, wird der Handler als `lambda_function.lambda_handler` angegeben. Dies ist der Standard-Handlername für Funktionen, die Sie mit der Lambda-Konsole erstellen.
Wenn Sie eine Funktion in der Konsole mit einem anderen Dateinamen oder Funktionshandlernamen erstellen, müssen Sie den Standardhandlernamen bearbeiten.
**So ändern Sie den Funktionshandlernamen (Konsole)**
1. Öffnen Sie die Seite [Functions (Funktionen)](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie eine Funktion aus.
1. Wählen Sie die Registerkarte **Code (Code)**.
1. Scrollen Sie nach unten zum Bereich **Laufzeiteinstellungen** und wählen Sie **Bearbeiten**.
1. Geben Sie unter **Handler** den neuen Namen für Ihren Funktionshandler ein.
1. Wählen Sie **Speichern**.
## Verwenden des Lambda-Ereignisobjekts
Wenn Lambda Ihre Funktion aufruft, wird dem Funktionshandler ein [Ereignisobjekt](concepts-basics.md#gettingstarted-concepts-event)-Argument übergeben. JSON-Objekte sind das gängigste Ereignisformat für Lambda-Funktionen. Im Codebeispiel im vorherigen Abschnitt erwartet die Funktion eine Eingabe im folgenden Format:
```
{
"Order_id": "12345",
"Amount": 199.99,
"Item": "Wireless Headphones"
}
```
Wenn Ihre Funktion von einem anderen AWS-Service aufgerufen wird, ist das Eingabeereignis ebenfalls ein JSON-Objekt. Das genaue Format des Ereignisobjekts hängt vom Service ab, der Ihre Funktion aufruft. Das Ereignisformat für einen bestimmten Service finden Sie auf der entsprechenden Seite im Kapitel „[Lambda mit Ereignissen aus anderen Diensten aufrufen AWS](lambda-services.md)“.
Wenn das Eingabeereignis in Form eines JSON-Objekts vorliegt, konvertiert die Lambda-Laufzeit das Objekt in ein Python-Wörterbuch. Um Werte in der Eingabe-JSON Variablen in Ihrem Code zuzuweisen, verwenden Sie die Standardmethoden für Python-Wörterbücher, wie im Beispielcode dargestellt.
Sie können Daten auch als JSON-Array oder als einen der anderen gültigen JSON-Datentypen an Ihre Funktion übergeben. In der folgenden Tabelle ist definiert, wie die Python-Laufzeit diese JSON-Typen konvertiert.
| JSON-Datentyp | Python-Datentyp |
| --- | --- |
| object | Wörterbuch (dict) |
| Array | Liste (list) |
| Zahl | Ganzzahl (int) oder Fließkommazahl (float) |
| Zeichenfolge | Zeichenfolge (str) |
| Boolesch | Boolesch (bool) |
| Null | NoneType (NoneType) |
## Zugreifen auf und Verwenden des Lambda-Kontextobjekts
Das Lambda-Kontextobjekt enthält Informationen über den Funktionsaufruf und die Ausführungsumgebung. Lambda übergibt das Kontextobjekt automatisch an Ihre Funktion, wenn diese aufgerufen wird. Mit dem Kontextobjekt können Sie zu Überwachungszwecken Informationen über den Aufruf Ihrer Funktion ausgeben.
Das Kontextobjekt ist eine Python-Klasse, die im [Schnittstellenclient der Lambda-Laufzeit](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/lambda_context.py) definiert ist. Um den Wert einer der Eigenschaften des Kontextobjekts zurückzugeben, verwenden Sie die entsprechende Methode des Kontextobjekts. Im folgenden Codeausschnitt wird beispielsweise der Wert der `aws_request_id`-Eigenschaft (die Kennung für die Aufrufanforderung) einer Variablen namens `request` zugewiesen.
```
request = context.aws_request_id
```
Weitere Informationen zur Verwendung des Lambda-Kontextobjekts und eine vollständige Liste der verfügbaren Methoden und Eigenschaften finden Sie unter [Verwenden des Lambda-Kontextobjekts zum Abrufen von Python-Funktionsinformationen](python-context.md).
## Gültige Handler-Signaturen für Python-Handler
Wenn Sie Ihre Handler-Funktion in Python definieren, muss die Funktion zwei Argumente enthalten. Das erste dieser Argumente ist das Lambda-[Ereignisobjekt](#python-handler-event) und das zweite ist das Lambda-[Kontextobjekt](#python-handler-context). Gemäß Konvention heißen diese Eingabeargumente in der Regel `event` und `context`, Sie können ihnen jedoch beliebige Namen geben. Wenn Sie Ihre Handler-Funktion mit einem einzigen Eingabeargument deklarieren, löst Lambda einen Fehler aus, wenn es versucht, Ihre Funktion auszuführen. Die gängigste Methode zum Deklarieren einer Handler-Funktion in Python ist wie folgt:
```
def lambda_handler(event, context):
```
Sie auch können Python-Typhinweise in Ihrer Funktionsdeklaration verwenden, wie im folgenden Beispiel gezeigt:
```
from typing import Dict, Any
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
```
Um spezifische AWS-Typisierungen für Ereignisse zu verwenden, die von anderen AWS-Services generiert werden, sowie für das Kontextobjekt, fügen Sie das Paket `aws-lambda-typing` zum Bereitstellungspaket Ihrer Funktion hinzu. Sie können diese Bibliothek in Ihrer Entwicklungsumgebung installieren, indem Sie `pip install aws-lambda-typing` ausführen. Der folgende Codeausschnitt zeigt, wie Sie AWS-spezifische Typhinweise verwenden. In diesem Beispiel ist das erwartete Ereignis ein Amazon-S3-Ereignis.
```
from aws_lambda_typing.events import S3Event
from aws_lambda_typing.context import Context
from typing import Dict, Any
def lambda_handler(event: S3Event, context: Context) -> Dict[str, Any]:
```
Sie können den Python-Funktionstyp `async` nicht für Ihre Handler-Funktion verwenden.
## Rückgabe eines Wertes
Optional kann ein Handler einen Wert zurückgeben, der JSON-serialisierbar sein muss. Zu den gängigen Rückgabetypen gehören `dict`, `list`, `str`, `int`, `float` und `bool`.
Was mit dem zurückgegebenen Wert passiert, hängt von der [Aufrufart](lambda-invocation.md) und dem [Service](lambda-services.md) ab, der die Funktion aufgerufen hat. Zum Beispiel:
+ Wenn Sie den Aufruftyp `RequestResponse` verwenden, um [eine Lambda-Funktion synchron aufzurufen](invocation-sync.md), gibt Lambda das Ergebnis des Python-Funktionsaufrufs an den Client zurück, der die Lambda-Funktion aufruft (in der HTTP-Antwort auf die Aufrufanforderung, serialisiert in JSON). Wenn eine AWS Lambda-Konsole zum Beispiel den Aufruftyp `RequestResponse` verwendet, zeigt die Konsole den zurückgegebenen Wert an, nachdem die Funktion auf der Konsole abgerufen wurde.
+ Wenn der Handler Objekte zurückgibt, die nicht von `json.dumps` serialisiert werden können, gibt die Laufzeit einen Fehler zurück.
+ Wenn der Handler `None` zurückgibt, wie es Python-Funktionen ohne eine `return`-Anweisung implizit tun, gibt die Laufzeit `null` zurück.
+ Wenn Sie den Aufruftyp `Event` ([asynchroner Aufruf](invocation-async.md)) verwenden, wird der Wert verworfen.
Im Beispielcode gibt der Handler das folgende Python-Wörterbuch zurück:
```
{
"statusCode": 200,
"message": "Receipt processed successfully"
}
```
Die Lambda-Laufzeit serialisiert dieses Wörterbuch und gibt es als JSON-Zeichenfolge an den Client zurück, der die Funktion aufgerufen hat.
**Anmerkung**
In Python 3.9 und späteren Versionen schließt Lambda die requestId des Aufrufs in die Fehlerantwort ein.
## Verwenden Sie das AWS SDK für Python (Boto3) in Ihrem Handler
Oft verwenden Sie Lambda-Funktionen, um mit anderen AWS-Services und Ressourcen zu interagieren. Die einfachste Art, eine Schnittstelle zu diesen Ressourcen herzustellen, ist die Verwendung von AWS SDK für Python (Boto3). Alle [unterstützten Lambda-Python-Laufzeiten](lambda-runtimes.md#runtimes-supported) enthalten eine Version des SDK für Python. Wir empfehlen jedoch dringend, das SDK in das Bereitstellungspaket Ihrer Funktion aufzunehmen, wenn Ihr Code es verwenden muss. Durch das Einfügen des SDK in Ihr Bereitstellungspaket erhalten Sie die volle Kontrolle über Ihre Abhängigkeiten und verringern das Risiko von Versionskonflikten mit anderen Bibliotheken. Weitere Informationen dazu finden Sie unter [Laufzeitabhängigkeiten in Python](python-package.md#python-package-dependencies) und [Abwärtskompatibilität](runtimes-update.md#runtime-update-compatibility).
Um das SDK für Python in Ihrer Lambda-Funktion zu verwenden, fügen Sie die folgende Anweisung zum Importblock am Anfang Ihres Funktionscodes hinzu:
```
import boto3
```
Verwenden den `pip install`-Befehl, um Bibliothek `boto3` dem Bereitstellungspaket Ihrer Funktion hinzuzufügen. Ausführliche Anweisungen zum Hinzufügen von Abhängigkeiten zu einem ZIP-Bereitstellungspaket finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](python-package.md#python-package-create-dependencies). Weitere Informationen zum Hinzufügen von Abhängigkeiten zu Lambda-Funktionen, die als Container-Images bereitgestellt werden, finden Sie unter [Erstellen eines Images aus einem Base Image](python-image.md#python-image-create) oder [Erstellen eines Images aus einem alternativen Basis-Image](python-image.md#python-alt-create).
Wenn Sie `boto3` in Ihrem Code verwenden, müssen Sie keine Anmeldeinformationen angeben, um einen Client zu initialisieren. Im Beispielcode verwenden wir beispielsweise die folgende Codezeile, um einen Amazon-S3-Client zu initialisieren:
```
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
```
Mit Python erstellt Lambda automatisch Umgebungsvariablen mit Anmeldeinformationen. Das `boto3` SDK überprüft die Umgebungsvariablen Ihrer Funktion bei der Initialisierung auf diese Anmeldeinformationen.
## Zugriff auf Umgebungsvariablen
In Ihrem Handler-Code können Sie mithilfe der `os.environ.get`-Methode auf [Umgebungsvariablen](configuration-envvars.md) verweisen. Im Beispielcode verweisen wir mit der folgenden Codezeile auf die definierte `RECEIPT_BUCKET`-Umgebungsvariable:
```
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
```
Vergessen Sie nicht, am Anfang Ihres Codes eine `import os`-Anweisung in den Importblock aufzunehmen.
## Bewährte Codemethoden für Python-Lambda-Funktionen
Halten Sie sich an die Richtlinien in der folgenden Liste, um beim Erstellen Ihrer Lambda-Funktionen die besten Codierungspraktiken anzuwenden:
+ **Trennen Sie den Lambda-Handler von Ihrer Core-Logik.** Auf diese Weise können Sie eine Funktion zur besseren Prüfbarkeit von Einheiten schaffen. In Python kann dies beispielsweise wie folgt aussehen:
```
def lambda_handler(event, context):
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo, bar)
def my_lambda_function(foo, bar):
// MyLambdaFunction logic here
```
+ **Kontrollieren Sie die Abhängigkeiten im Bereitstellungspaket Ihrer Funktion.** Die AWS Lambda-Ausführungsumgebung enthält eine Reihe von Bibliotheken. Für die Laufzeiten Node.js und Python gehören dazu die AWS-SDKs. Um die neuesten Funktionen und Sicherheitsupdates zu aktivieren, wird Lambda diese Bibliotheken regelmäßig aktualisieren. Diese Updates können das Verhalten Ihrer Lambda-Funktion geringfügig verändern. Um die Abhängigkeiten, die Ihre Funktion verwendet, vollständig zu kontrollieren, empfehlen wir, alle Abhängigkeiten mit Ihrem Bereitstellungspaket zu bündeln.
+ **Minimieren Sie die Komplexität Ihrer Abhängigkeiten.** Ziehen Sie einfachere Frameworks vor, die sich schnell beim Start der [Ausführungsumgebung](lambda-runtime-environment.md) laden lassen.
+ **Minimieren Sie die Größe Ihres Bereitstellungspakets auf die für die Laufzeit erforderliche Größe. ** Dadurch verkürzt sich die Zeit, die für das Herunterladen und Entpacken Ihres Bereitstellungspakets vor dem Aufruf benötigt wird.
**Nutzen Sie die Wiederverwendung der Ausführungsumgebung zur Verbesserung Ihrer Funktion.** Initialisieren Sie SDK-Clients und Datenbankverbindungen außerhalb des Funktions-Handlers und speichern Sie statische Komponenten lokal im `/tmp`-Verzeichnis. Nachfolgende Aufrufe, die von derselben Instance Ihrer Funktion verarbeitet werden, können diese Ressourcen wiederverwenden. Dies spart Kosten durch Reduzierung der Funktionslaufzeit.
Um potenzielle Datenlecks über Aufrufe hinweg zu vermeiden, verwenden Sie die Ausführungsumgebung nicht, um Benutzerdaten, Ereignisse oder andere Informationen mit Sicherheitsauswirkungen zu speichern. Wenn Ihre Funktion auf einem veränderbaren Zustand beruht, der nicht im Speicher innerhalb des Handlers gespeichert werden kann, sollten Sie für jeden Benutzer eine separate Funktion oder separate Versionen einer Funktion erstellen.
**Verwenden Sie eine Keep-Alive-Direktive, um dauerhafte Verbindungen zu pflegen.** Lambda bereinigt Leerlaufverbindungen im Laufe der Zeit. Der Versuch, eine Leerlaufverbindung beim Aufruf einer Funktion wiederzuverwenden, führt zu einem Verbindungsfehler. Um Ihre persistente Verbindung aufrechtzuerhalten, verwenden Sie die Keep-Alive-Direktive, die Ihrer Laufzeit zugeordnet ist. Ein Beispiel finden Sie unter [Wiederverwenden von Verbindungen mit Keep-Alive in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Verwenden Sie [Umgebungsvariablen](configuration-envvars.md) um Betriebsparameter an Ihre Funktion zu übergeben.** Wenn Sie z. B. Daten in einen Amazon-S3-Bucket schreiben, anstatt den Bucket-Namen, in den Sie schreiben, hartzucodieren, konfigurieren Sie den Bucket-Namen als Umgebungsvariable.
**Vermeiden Sie rekursive Aufrufe** in Ihrer Lambda-Funktion, bei denen die Funktion sich selbst aufruft oder einen Prozess initiiert, der die Funktion erneut aufrufen kann. Dies kann zu unvorhergesehenen Mengen an Funktionsaufrufen führen und höhere Kosten zur Folge haben. Wenn Sie eine unbeabsichtigte Menge von Aufrufen feststellen, legen Sie die reservierte gleichzeitige Ausführung der Funktion auf `0` fest, um sofort alle Aufrufe der Funktion zu drosseln, während Sie den Code aktualisieren.
**Verwenden Sie keine nicht dokumentierten, nicht öffentlichen APIs** in Ihrem Lambda-Funktionscode. Für AWS Lambda-verwaltete Laufzeiten wendet Lambda regelmäßig Sicherheits- und Funktionsupdates auf Lambdas interne APIs an. Diese internen API-Updates können abwärtskompatibel sein, was zu unbeabsichtigten Konsequenzen wie Aufruffehlern führt, wenn Ihre Funktion von diesen nicht öffentlichen APIs abhängig ist. Eine Liste öffentlich zugänglicher APIs finden Sie in der [API-Referenz](https://docs.aws.amazon.com/lambda/latest/api/welcome.html).
**Schreiben Sie idempotenten Code.** Das Schreiben idempotenter Code für Ihre Funktionen stellt sicher, dass doppelte Ereignisse auf die gleiche Weise behandelt werden. Ihr Code sollte Ereignisse ordnungsgemäß validieren und doppelte Ereignisse ordnungsgemäß behandeln. Weitere Informationen finden Sie unter [Wie mache ich meine Lambda-Funktion idempotent?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Arbeiten mit ZIP-Dateiarchiven und Python-Lambda-Funktionen
Der Code Ihrer AWS Lambda Funktion besteht aus einer .py-Datei, die den Handlercode Ihrer Funktion enthält, zusammen mit allen zusätzlichen Paketen und Modulen, von denen Ihr Code abhängt. Sie verwenden ein *Bereitstellungspaket*, um Ihren Funktionscode in Lambda bereitzustellen. Dieses Paket kann entweder ein ZIP-Dateiarchiv oder ein Container-Image sein. Weitere Informationen zur Verwendung von Container-Images mit Python finden Sie unter [Bereitstellen von Python-Lambda-Funktionen mit Container-Images](https://docs.aws.amazon.com/lambda/latest/dg/python-image.html).
Zum Erstellen des Bereitstellungspakets für ein ZIP-Dateiarchiv können Sie ein integriertes Dienstprogramm für ZIP-Dateien Ihres Befehlzeilen-Tools oder ein anderes Dienstprogramm für ZIP-Dateien verwenden, wie [7zip](https://www.7-zip.org/download.html). In den Beispiele in den folgenden Abschnitten wird davon ausgegangen, dass Sie ein `zip`-Befehlszeilen-Tool in einer Linux- oder MacOS-Umgebung verwenden. Unter Windows können Sie das [Windows-Subsystem für Linux installieren](https://docs.microsoft.com/en-us/windows/wsl/install-win10), um eine Windows-Version von Ubuntu und Bash zu erhalten und dieselben Befehle zu verwenden.
Da Lambda POSIX-Dateiberechtigungen verwendet, müssen Sie möglicherweise [Berechtigungen für den Bereitstellungspaketordner festlegen](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/), bevor Sie das ZIP-Dateiarchiv erstellen.
**Topics**
+ [Laufzeitabhängigkeiten in Python](#python-package-dependencies)
+ [ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen](#python-package-create-no-dependencies)
+ [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](#python-package-create-dependencies)
+ [Suchpfad für Abhängigkeiten und integrierte Laufzeit-Bibliotheken](#python-package-searchpath)
+ [\$1\$1pycache\$1\$1-Ordner verwenden](#python-package-pycache)
+ [ZIP-Bereitstellungspakete mit nativen Bibliotheken erstellen](#python-package-native-libraries)
+ [Python-Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren](#python-package-create-update)
## Laufzeitabhängigkeiten in Python
Für Lambda-Funktionen, die die Python-Laufzeit verwenden, kann eine Abhängigkeit ein beliebiges Python-Paket oder -Modul sein. Bei Bereitstellung Ihrer Funktion mithilfe eines ZIP-Archivs können Sie diese Abhängigkeiten entweder mit Ihrem Funktionscode zu Ihrer ZIP-Datei hinzufügen oder eine [Lambda-Ebene](chapter-layers.md) verwenden. Eine Ebene ist ein separates ZIP-Dateiarchiv, das zusätzlichen Code und andere Daten enthalten kann. Weitere Informationen zur Verwendung von Lambda-Ebenen in Python finden Sie unter [Arbeiten mit Ebenen für Python Lambda-Funktionen](python-layers.md).
Die Lambda-Python-Laufzeiten beinhalten die AWS SDK für Python (Boto3) und ihre Abhängigkeiten. Lambda stellt das SDK in der Laufzeit für Bereitstellungsszenarien bereit, in denen Sie keine eigenen Abhängigkeiten hinzufügen können. Zu diesen Szenarien gehören die Erstellung von Funktionen in der Konsole mithilfe des integrierten Code-Editors oder die Verwendung von Inline-Funktionen in AWS Serverless Application Model (AWS SAM) oder CloudFormation Vorlagen.
Lambda aktualisiert die Bibliotheken in der Python-Laufzeit regelmäßig, um die neuesten Updates und Sicherheitspatches aufzunehmen. Wenn Ihre Funktion die in der Runtime enthaltene Version des Boto3-SDK verwendet, Ihr Bereitstellungspaket jedoch SDK-Abhängigkeiten enthält, kann dies zu Versionsproblemen führen. Ihr Bereitstellungspaket enthält beispielsweise die SDK-Abhängigkeit urllib3. Aktualisiert Lambda das SDK während der Laufzeit, können Kompatibilitätsprobleme zwischen der neuen Version der Laufzeit und der Version von urllib3 in Ihrem Bereitstellungspaket dazu führen, dass Ihre Funktion fehlschlägt.
**Wichtig**
Um die volle Kontrolle über Ihre Abhängigkeiten zu behalten und mögliche Versionsprobleme zu vermeiden, empfehlen wir Ihnen, alle Abhängigkeiten Ihrer Funktion zu Ihrem Bereitstellungspaket hinzuzufügen, auch wenn Versionen davon in der Lambda-Laufzeit enthalten sind. Dazu gehört das Boto3-SDK.
Informationen darüber, welche Version des SDK für Python (Boto3) in der von Ihnen verwendeten Laufzeit enthalten ist, finden Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](lambda-python.md#python-sdk-included).
Im Rahmen des [AWS -Modells der geteilten Verantwortung](https://docs.aws.amazon.com/whitepapers/latest/aws-risk-and-compliance/shared-responsibility-model.html) sind Sie für die Verwaltung aller Abhängigkeiten in den Bereitstellungspaketen Ihrer Funktionen verantwortlich. Dies beinhaltet das Durchführen von Updates und Sicherheitspatches. Zum Aktualisieren von Abhängigkeiten im Bereitstellungspaket Ihrer Funktion erstellen Sie zunächst eine neue ZIP-Datei und laden Sie diese dann in Lambda hoch. Weitere Informationen finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](#python-package-create-dependencies) und [Python-Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren](#python-package-create-update).
## ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen
Hat Ihr Funktionscode keine Abhängigkeiten, enthält Ihre ZIP-Datei nur die PY-Datei mit dem Handler-Code Ihrer Funktion. Erstellen Sie mit Ihrem bevorzugten ZIP-Programm eine ZIP-Datei mit Ihrer PY-Datei im Stammverzeichnis. Befindet sich die PY-Datei nicht im Stammverzeichnis Ihrer ZIP-Datei, kann Lambda Ihren Code nicht ausführen.
Informationen zum Bereitstellen Ihrer ZIP-Datei zum Erstellen einer neuen Lambda-Funktion oder Aktualisieren einer vorhandenen Funktion, finden Sie unter [Python-Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren](#python-package-create-update).
## ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen
Hängt Ihr Funktionscode von zusätzlichen Paketen und Modulen ab, können Sie diese Abhängigkeiten entweder mit Ihrem Funktionscode zu Ihrer ZIP-Datei hinzufügen oder eine [Lambda-Ebene verwenden](python-layers.md). Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie Ihre Abhängigkeiten in Ihr ZIP-Bereitstellungspaket aufnehmen. Damit Lambda Ihren Code ausführen kann, muss die PY-Datei, die Ihren Handler-Code und alle Abhängigkeiten Ihrer Funktion enthält, im Stammverzeichnis der ZIP-Datei installiert werden.
Angenommen, Ihr Funktionscode ist in einer Datei mit dem Namen „`lambda_function.py`“ gespeichert. Die folgenden CLI-Befehle erstellen Sie eine ZIP-Datei mit dem Namen „`my_deployment_package.zip`“, die Ihren Funktionscode und seine Abhängigkeiten enthält. Sie können Ihre Abhängigkeiten entweder direkt in einem Ordner in Ihrem Projektverzeichnis installieren oder eine virtuelle Python-Umgebung verwenden.
**So erstellen Sie das Bereitstellungspaket (Projektverzeichnis)**
1. Navigieren Sie zum Projektverzeichnis, das Ihre `lambda_function.py`-Quellcodedatei enthält. In diesem Beispiel trägt das Verzeichnis den Namen `my_function`.
```
cd my_function
```
1. Erstellen Sie ein neues Verzeichnis mit dem Namen „package“, in das Sie Ihre Abhängigkeiten installieren.
```
mkdir package
```
Beachten Sie, dass Lambda bei einem ZIP-Bereitstellungspaket erwartet, dass sich Ihr Quellcode und seine Abhängigkeiten im Stammverzeichnis der ZIP-Datei befinden. Installieren Sie jedoch Abhängigkeiten direkt in Ihrem Projektverzeichnis, kann dies zu einer großen Anzahl neuer Dateien und Ordner führen und das Navigieren in Ihrer IDE erschweren. Sie erstellen hier ein separates `package`-Verzeichnis, um Ihre Abhängigkeiten von Ihrem Quellcode zu trennen.
1. Installieren Sie Ihre Abhängigkeiten im `package`-Verzeichnis. Im folgenden Beispiel wird das Boto3-SDK aus dem Python-Paketindex mithilfe von pip installiert. Verwendet Ihr Funktionscode selbst erstellte Python-Pakete, speichern Sie diese im `package`-Verzeichnis.
```
pip install --target ./package boto3
```
1. Erstellen Sie eine ZIP-Datei mit den installierten Bibliotheken im Stammverzeichnis.
```
cd package
zip -r ../my_deployment_package.zip .
```
Dadurch wird eine `my_deployment_package.zip`-Datei in Ihrem Projektverzeichnis generiert.
1. Fügen Sie die Datei „lambda\$1function.py“ dem Stammverzeichnis der ZIP-Datei hinzu.
```
cd ..
zip my_deployment_package.zip lambda_function.py
```
Ihre ZIP-Datei sollte eine flache Verzeichnisstruktur haben, wobei der Handler-Code Ihrer Funktion und alle Ihre Abhängigkeitsordner wie folgt im Stammverzeichnis installiert sind.
```
my_deployment_package.zip
|- bin
| |-jp.py
|- boto3
| |-compat.py
| |-data
| |-docs
...
|- lambda_function.py
```
Befindet sich die PY-Datei mit dem Handler-Code Ihrer Funktion nicht im Stammverzeichnis Ihrer ZIP-Datei, kann Lambda Ihren Code nicht ausführen.
**So erstellen Sie das Bereitstellungspaket (virtuelle Umgebung)**
1. Erstellen und aktivieren Sie eine virtuelle Umgebung in Ihrem Projektverzeichnis. In diesem Beispiel trägt das Projektverzeichnis den Namen „`my_function`“.
```
~$ cd my_function
~/my_function$ python3.14 -m venv my_virtual_env
~/my_function$ source ./my_virtual_env/bin/activate
```
1. Installieren Sie Ihre erforderlichen Bibliotheken mithilfe von pip. Im folgenden Beispiel wird das Boto3-SDK installiert.
```
(my_virtual_env) ~/my_function$ pip install boto3
```
1. Verwenden Sie `pip show`, um den Ort in Ihrer virtuellen Umgebung zu finden, an dem pip Ihre Abhängigkeiten installiert hat.
```
(my_virtual_env) ~/my_function$ pip show
```
Der Ordner, in dem pip Ihre Bibliotheken installiert, heißt entweder „`site-packages`“ oder „`dist-packages`“. Dieser Ordner befindet sich entweder im Verzeichnis „`lib/python3.x`“ oder „`lib64/python3.x`“ (wobei „python3.x“ die verwendete Python-Version ist).
1. Deaktivieren Sie die virtuelle Umgebung.
```
(my_virtual_env) ~/my_function$ deactivate
```
1. Navigieren Sie in das Verzeichnis mit den Abhängigkeiten, die Sie mit pip installiert haben, und erstellen Sie eine ZIP-Datei in Ihrem Projektverzeichnis mit den installierten Abhängigkeiten im Stammverzeichnis. In diesem Beispiel hat pip Ihre Abhängigkeiten im Verzeichnis „`my_virtual_env/lib/python3.14/site-packages`“ installiert.
```
~/my_function$ cd my_virtual_env/lib/python3.14/site-packages
~/my_function/my_virtual_env/lib/python3.14/site-packages$ zip -r ../../../../my_deployment_package.zip .
```
1. Navigieren Sie zum Stammverzeichnis Ihres Projektverzeichnisses, in dem sich die PY-Datei mit Ihrem Handler-Code befindet, und fügen Sie diese Datei dem Stammverzeichnis Ihres ZIP-Pakets hinzu. In diesem Beispiel heißt Ihre Funktionscodedatei „`lambda_function.py`“.
```
~/my_function/my_virtual_env/lib/python3.14/site-packages$ cd ../../../../
~/my_function$ zip my_deployment_package.zip lambda_function.py
```
## Suchpfad für Abhängigkeiten und integrierte Laufzeit-Bibliotheken
Wenn Sie in Ihrem Code eine `import`-Anweisung verwenden, durchsucht die Python-Laufzeit die Verzeichnisse in ihrem Suchpfad, bis sie das Modul oder Paket findet. Standardmäßig ist der erste Speicherort, den die Laufzeit durchsucht, das Verzeichnis, in das Ihr ZIP-Bereitstellungspaket entpackt und bereitgestellt wird (`/var/task`). Wenn Sie eine Version einer in der Laufzeit enthaltenen Bibliothek in Ihr Bereitstellungspaket einfügen, hat Ihre Version Vorrang vor der Version, die in der Laufzeit enthalten ist. Abhängigkeiten in Ihrem Bereitstellungspaket haben ebenfalls Vorrang vor Abhängigkeiten in Ebenen.
Wenn Sie einer Ebene eine Abhängigkeit hinzufügen, extrahiert Lambda diese in `/opt/python/lib/python3.x/site-packages` (wobei `python3.x` die von Ihnen verwendete Version der Laufzeit ist) oder in `/opt/python`. Im Suchpfad haben diese Verzeichnisse Vorrang vor den Verzeichnissen, die die in der Laufzeit enthaltenen Bibliotheken und die über pip installierten Bibliotheken enthalten (`/var/runtime` und `/var/lang/lib/python3.x/site-packages`). Bibliotheken in Funktionsebenen haben daher Vorrang vor Versionen, die in der Laufzeit enthalten sind.
**Anmerkung**
Im verwalteten Runtime- und Basis-Image von Python 3.11 sind das AWS SDK und seine Abhängigkeiten im `/var/lang/lib/python3.11/site-packages` Verzeichnis installiert.
Sie können den vollständigen Suchpfad für Ihre Lambda-Funktion sehen, indem Sie den folgenden Codeausschnitt hinzufügen.
```
import sys
search_path = sys.path
print(search_path)
```
**Anmerkung**
Da Abhängigkeiten in Ihrem Bereitstellungspaket oder Ihren Ebenen Vorrang vor Bibliotheken haben, die zur Laufzeit gehören, kann es zu Versionsproblemen kommen, wenn Sie eine SDK-Abhängigkeit wie urllib3 in Ihr Paket aufnehmen, ohne das SDK ebenfalls einzubetten. Stellen Sie Ihre eigene Version einer Boto3-Abhängigkeit bereit, müssen Sie Boto3 auch als Abhängigkeit in Ihrem Bereitstellungspaket bereitstellen. Wir empfehlen, alle Abhängigkeiten Ihrer Funktion in ein Paket aufzunehmen, auch wenn Versionen davon in der Laufzeit enthalten sind.
Fügen Sie Abhängigkeiten alternativ auch in einem separaten Ordner in Ihrem ZIP-Paket hinzu. Fügen Sie beispielsweise eine Version des Boto3-SDK zu einem Ordner in Ihrem ZIP-Paket mit dem Namen „`common`“ hinzu. Wird Ihr ZIP-Paket entpackt und bereitgestellt, wird dieser Ordner im Verzeichnis „`/var/task`“ abgelegt. Mit einer `import from`-Anweisung verwenden Sie eine Abhängigkeit aus einem Ordner Ihres ZIP-Bereitstellungspakets in Ihrem Code. Verwenden Sie mithilfe folgender Anweisung beispielsweise eine Version von Boto3 aus einem Ordner, der in Ihrem ZIP-Paket „`common`“ heißt.
```
from common import boto3
```
## \$1\$1pycache\$1\$1-Ordner verwenden
Es wird empfohlen, keine `__pycache__`-Ordner in das Bereitstellungspaket Ihrer Funktion aufzunehmen. Python-Bytecode, der auf einem Build-Computer mit einer anderen Architektur oder in einem anderen Betriebssystem kompiliert wurde, ist möglicherweise nicht mit der Lambda-Ausführungsumgebung kompatibel.
## ZIP-Bereitstellungspakete mit nativen Bibliotheken erstellen
Verwendet Ihre Funktion nur reine Python-Pakete und -Module, können Sie mit dem `pip install`-Befehl Ihre Abhängigkeiten auf einem beliebigen lokalen Build-Computer installieren und Ihre ZIP-Datei erstellen. Viele beliebte Python-Bibliotheken, darunter NumPy Pandas, sind kein reines Python und enthalten in C oder C\$1\$1 geschriebenen Code. Fügen Sie Ihrem Bereitstellungspaket Bibliotheken hinzu, die C-/C\$1\$1-Code enthalten, müssen Sie Ihr Paket korrekt erstellen, damit es mit der Lambda-Ausführungsumgebung kompatibel ist.
Die meisten Pakete im Python-Paketindex ([PyPI](https://pypi.org/)) sind als „Wheels“ (WHL-Dateien) verfügbar. Eine WHL-Datei ist eine Art von ZIP-Datei, die eine erstellte Distribution mit vorkompilierten Binärdateien für ein bestimmtes Betriebssystem und eine bestimmte Befehlssatzarchitektur enthält. Für die Kompatibilität Ihres Bereitstellungspakets mit Lambda installieren Sie das Wheel für Linux-Betriebssysteme und die Befehlssatzarchitektur Ihrer Funktion.
Einige Pakete sind möglicherweise nur als Quelldistributionen verfügbar. Für diese Pakete müssen Sie die C-/C\$1\$1-Komponenten selbst kompilieren und erstellen.
Gehen Sie wie folgt vor, um anzuzeigen, welche Distributionen für Ihr erforderliches Paket verfügbar sind:
1. Suchen Sie auf der [Hauptseite des Python-Paketindex](https://pypi.org/) nach dem Namen des Pakets.
1. Wählen Sie die Paketversion aus, die Sie verwenden möchten.
1. Wählen Sie **Dateien zum Herunterladen** aus.
### Mit erstellten Distributionen (Wheels) arbeiten
Zum Herunterladen eines Wheels, das mit Lambda kompatibel ist, verwenden Sie die pip-Option „`--platform`“.
Verwendet Ihre Lambda-Funktion die **x86\$164**-Befehlssatzarchitektur, führen Sie den folgenden `pip install`-Befehl aus, um ein kompatibles Wheel in Ihrem `package`-Verzeichnis zu installieren. Ersetzen Sie „`--python 3.x`“ durch die Version der verwendeten Python-Laufzeit.
```
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
Verwendet Ihre Funktion die **arm64**-Befehlssatzarchitektur, führen Sie den folgenden Befehl aus. Ersetzen Sie „`--python 3.x`“ durch die Version der verwendeten Python-Laufzeit.
```
pip install \
--platform manylinux2014_aarch64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
### Mit Quelldistributionen arbeiten
Ist Ihr Paket nur als Quelldistribution verfügbar, müssen Sie die C-/C\$1\$1-Bibliotheken selbst erstellen. Für die Kompatibilität Ihres Pakets mit der Lambda-Ausführungsumgebung müssen Sie es in einer Umgebung erstellen, die dasselbe Amazon-Linux-Betriebssystem verwendet. Sie können dies tun, indem Sie Ihr Paket in einer Amazon Elastic Compute Cloud (Amazon EC2) Linux-Instance erstellen.
Informationen zum Starten und Herstellen einer Verbindung zu einer Amazon EC2 Linux-Instance finden [Sie unter Erste Schritte mit Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) *im EC2 Amazon-Benutzerhandbuch*.
## Python-Lambda-Funktionen mithilfe von ZIP-Dateien erstellen und aktualisieren
Nach der Erstellung Ihres ZIP-Bereitstellungspakets können Sie es verwenden, um eine neue Lambda-Funktion zu erstellen oder eine vorhandene zu aktualisieren. Sie können Ihr .zip-Paket mithilfe der Lambda-Konsole, der und der AWS Command Line Interface Lambda-API bereitstellen. Sie können Lambda-Funktionen auch mit AWS Serverless Application Model (AWS SAM) und CloudFormation erstellen und aktualisieren.
Die maximale Größe eines ZIP-Bereitstellungspakets für Lambda beträgt 250 MB (entpackt). Beachten Sie, dass dieser Grenzwert für die kombinierte Größe aller hochgeladenen Dateien gilt, einschließlich aller Lambda-Ebenen.
Die Lambda-Laufzeit benötigt die Berechtigung zum Lesen der Dateien in Ihrem Bereitstellungspaket. In der oktalen Schreibweise von Linux-Berechtigungen benötigt Lambda 644 Berechtigungen für nicht ausführbare Dateien (rw-r--r--) und 755 Berechtigungen () für Verzeichnisse und ausführbare Dateien. rwxr-xr-x
Verwenden Sie unter Linux und MacOS den `chmod`-Befehl, um Dateiberechtigungen für Dateien und Verzeichnisse in Ihrem Bereitstellungspaket zu ändern. Um beispielsweise einer nicht ausführbaren Datei die richtigen Berechtigungen zu geben, führen Sie den folgenden Befehl aus.
```
chmod 644
```
Informationen zum Ändern von Dateiberechtigungen in Windows finden Sie unter [Festlegen, Anzeigen, Ändern oder Entfernen von Berechtigungen für ein Objekt](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) in der Microsoft-Windows-Dokumentation.
**Anmerkung**
Wenn Sie Lambda nicht die Berechtigungen gewähren, die es für den Zugriff auf Verzeichnisse in Ihrem Bereitstellungspaket benötigt, setzt Lambda die Berechtigungen für diese Verzeichnisse auf 755 (). rwxr-xr-x
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Konsole
Eine neue Funktion müssen Sie zuerst in der Konsole erstellen und dann Ihr ZIP-Archiv hochladen. Zum Aktualisieren einer bestehenden Funktion öffnen Sie die Seite für Ihre Funktion und gehen dann genauso vor, um Ihre aktualisierte ZIP-Datei hinzuzufügen.
Bei einer ZIP-Datei mit unter 50 MB können Sie eine Funktion erstellen oder aktualisieren, indem Sie die Datei direkt von Ihrem lokalen Computer hochladen. Bei ZIP-Dateien mit einer Größe von mehr als 50 MB müssen Sie Ihr Paket zuerst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3-Bucket mithilfe von finden Sie unter [Erste Schritte mit Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). AWS-Managementkonsole Informationen zum Hochladen von Dateien mit dem AWS CLI finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*.
**Anmerkung**
Sie können den [Bereitstellungspakettyp](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip oder Container-Image) für eine vorhandene Funktion nicht ändern. Sie können zum Beispiel eine Container-Image-Funktion nicht so umwandeln, dass sie ein .zip-Archiv verwendet. Sie müssen eine neue Funktion erstellen.
**So erstellen Sie eine neue Funktion (Konsole)**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie **Funktion erstellen** aus.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie als **Funktionsname** den Namen Ihrer Funktion ein.
1. Wählen Sie für **Laufzeit** die Laufzeit aus, die Sie verwenden möchten.
1. (Optional) Für **Architektur** wählen Sie die Befehlssatz-Architektur für Ihre Funktion aus. Die Standardarchitektur ist x86\$164. Stellen Sie sicher, dass das ZIP-Bereitstellungspaket für Ihre Funktion mit der von Ihnen gewählten Befehlssatzarchitektur kompatibel ist.
1. (Optional) Erweitern Sie unter **Berechtigungen** die Option **Standardausführungsrolle ändern**. Sie können eine neue **Ausführungsrolle** erstellen oder eine vorhandene Rolle verwenden.
1. Wählen Sie **Funktion erstellen**. Lambda erstellt eine grundlegende „Hello World“-Funktion mit der von Ihnen gewählten Laufzeit.
**So laden Sie ein ZIP-Archiv von Ihrem lokalen Computer hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie die ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie die **ZIP-Datei** aus.
1. Laden Sie die ZIP-Datei wie folgt hoch:
1. Wählen Sie **Hochladen** und dann Ihre ZIP-Datei in der Dateiauswahl aus.
1. Klicken Sie auf **Open**.
1. Wählen Sie **Speichern**.
**So laden Sie ein ZIP-Archiv aus einem Amazon-S3-Bucket hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie eine neue ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie den **Amazon-S3-Speicherort** aus.
1. Fügen Sie die Amazon-S3-Link-URL Ihrer ZIP-Datei ein und wählen Sie **Speichern** aus.
### ZIP-Dateifunktionen mithilfe des Konsolencode-Editors aktualisieren
Für einige Funktionen mit ZIP-Bereitstellungspaketen können Sie Ihren Funktionscode direkt mit dem in der Lambda-Konsole integrierten Code-Editor aktualisieren. Zur Verwendung dieses Features muss Ihre Funktion folgende Kriterien erfüllen:
+ Ihre Funktion muss eine der interpretierten Sprache der Laufzeit verwenden (Python, Node.js oder Ruby).
+ Das Bereitstellungspaket Ihrer Funktion muss kleiner als 50 MB (entpackt) sein.
Funktionscode für Funktionen mit Container-Image-Bereitstellungspaketen kann nicht direkt in der Konsole bearbeitet werden.
**So aktualiseren Sie Ihren Funktionscode mit dem Code-Editor**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion aus.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** Ihre Quellcodedatei aus und bearbeiten Sie sie im integrierten Code-Editor.
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien mithilfe der AWS CLI
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) verwenden, um eine neue Funktion zu erstellen oder eine vorhandene unter Verwendung einer ZIP-Datei zu aktualisieren. Verwenden Sie die [Erstellungsfunktion und](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) die [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)Befehle, um Ihr .zip-Paket bereitzustellen. Wenn Ihre ZIP-Datei kleiner als 50 MB ist, können Sie das ZIP-Paket von einem Dateispeicherort auf Ihrem lokalen Build-Computer hochladen. Bei größeren Dateien müssen Sie Ihr ZIP-Paket aus einem Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*. AWS CLI
**Anmerkung**
Wenn Sie Ihre ZIP-Datei mithilfe von aus einem Amazon S3 S3-Bucket hochladen AWS CLI, muss sich der Bucket im selben Verzeichnis befinden AWS-Region wie Ihre Funktion.
Um eine neue Funktion mithilfe einer .zip-Datei mit dem zu erstellen AWS CLI, müssen Sie Folgendes angeben:
+ Den Namen Ihrer Funktion (`--function-name`)
+ Die Laufzeit Ihrer Funktion (`--runtime`)
+ Den Amazon-Ressourcennamen (ARN) der [Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) der Funktion (`--role`).
+ Den Namen der Handler-Methode in Ihrem Funktionscode (`--handler`)
Sie müssen auch den Speicherort Ihrer ZIP-Datei angeben. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigte `--code`-Option. Sie müssen den `S3ObjectVersion`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Um eine vorhandene Funktion mit der CLI zu aktualisieren, geben Sie den Namen Ihrer Funktion unter Verwendung des `--function-name`-Parameters an. Sie müssen auch den Speicherort der ZIP-Datei angeben, die Sie zum Aktualisieren Ihres Funktionscodes verwenden möchten. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigten `--s3-bucket`- und `--s3-key`-Optionen. Sie müssen den `--s3-object-version`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Lambda-API
Um Funktionen zu erstellen und zu konfigurieren, die ein ZIP-Dateiarchiv verwenden, verwenden Sie die folgenden API-Operationen:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Funktionen mit ZIP-Dateien erstellen und aktualisieren mit AWS SAM
Das AWS Serverless Application Model (AWS SAM) ist ein Toolkit, das dabei hilft, den Prozess der Erstellung und Ausführung serverloser Anwendungen zu optimieren. AWS Sie definieren die Ressourcen für Ihre Anwendung in einer YAML- oder JSON-Vorlage und verwenden die AWS SAM Befehlszeilenschnittstelle (AWS SAM CLI), um Ihre Anwendungen zu erstellen, zu verpacken und bereitzustellen. Wenn Sie eine Lambda-Funktion aus einer AWS SAM Vorlage erstellen, AWS SAM wird automatisch ein ZIP-Bereitstellungspaket oder ein Container-Image mit Ihrem Funktionscode und allen von Ihnen angegebenen Abhängigkeiten erstellt. Weitere Informationen zur Verwendung AWS SAM zum Erstellen und Bereitstellen von Lambda-Funktionen finden Sie unter [Erste Schritte mit AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) im *AWS Serverless Application Model Entwicklerhandbuch*.
Sie können es auch verwenden AWS SAM , um eine Lambda-Funktion mithilfe eines vorhandenen ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion zu erstellen AWS SAM, können Sie Ihre ZIP-Datei in einem Amazon S3 S3-Bucket oder in einem lokalen Ordner auf Ihrem Build-Computer speichern. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch*. AWS CLI
In Ihrer AWS SAM Vorlage spezifiziert die `AWS::Serverless::Function` Ressource Ihre Lambda-Funktion. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `CodeUri`- auf die Amazon S3 S3-URI, den Pfad zum lokalen Ordner oder [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)Objekt des Funktionscodes gesetzt
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Wenn Ihre ZIP-Datei größer als 50 MB ist, müssen Sie sie nicht zuerst in einen Amazon S3 S3-Bucket hochladen. AWS SAM AWS SAM kann .zip-Pakete bis zur maximal zulässigen Größe von 250 MB (entpackt) von einem Speicherort auf Ihrem lokalen Build-Computer hochladen.
*Weitere Informationen zum Bereitstellen von Funktionen mithilfe der ZIP-Datei in finden Sie [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)im AWS SAM Entwicklerhandbuch.AWS SAM *
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien mithilfe von CloudFormation
Sie können verwenden CloudFormation , um eine Lambda-Funktion mithilfe eines ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion aus einer ZIP-Datei zu erstellen, müssen Sie Ihre Datei zunächst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon S3 S3-Bucket mithilfe von finden Sie unter [Objekte verschieben](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI Benutzerhandbuch. AWS CLI*
Für Node.js- und Python-Laufzeiten können Sie auch Inline-Quellcode in Ihrer CloudFormation Vorlage bereitstellen. CloudFormation erstellt dann eine ZIP-Datei, die Ihren Code enthält, wenn Sie Ihre Funktion erstellen.
**Eine vorhandene ZIP-Datei verwenden**
In Ihrer CloudFormation Vorlage spezifiziert die `AWS::Lambda::Function` Ressource Ihre Lambda-Funktion. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `Code` – Geben Sie den Namen des Amazon-S3-Buckets und den ZIP-Dateinamen in die Felder `S3Bucket` und `S3Key` ein
+ `Runtime` – festlegen auf die gewünschte Laufzeit
**Eine ZIP-Datei aus dem Inline-Code erstellen**
Sie können einfache Funktionen, die in Python oder Node.js geschrieben wurden, inline in einer CloudFormation Vorlage deklarieren. Da der Code in YAML oder JSON eingebettet ist, können Sie Ihrem Bereitstellungspaket keine externen Abhängigkeiten hinzufügen. Das bedeutet, dass Ihre Funktion die Version des AWS SDK verwenden muss, die in der Laufzeit enthalten ist. Die Anforderungen der Vorlage, wie die Notwendigkeit von Escapezeichen für bestimmte Zeichen, erschweren ebenfalls die Verwendung von IDE-Features zur Syntaxprüfung und Codevervollständigung. Ihre Vorlage erfordert deshalb möglicherweise zusätzliche Tests. Aufgrund dieser Einschränkungen eignet sich die Inline-Deklaration von Funktionen am besten für sehr einfachen Code, der sich nicht häufig ändert.
Zum Erstellen einer ZIP-Datei aus Inline-Code für Node.js- und Python-Laufzeiten legen Sie die folgenden Eigenschaften in der Ressource Ihrer `AWS::Lambda::Function`-Vorlage fest:
+ `PackageType` – festlegen auf `Zip`
+ `Code` – Funktionscode in das `ZipFile`-Feld eingeben
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Die CloudFormation generierte ZIP-Datei darf 4 MB nicht überschreiten. *Weitere Informationen zum Bereitstellen von Funktionen mithilfe der ZIP-Datei finden Sie [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)im CloudFormation Benutzerhandbuch. CloudFormation*
# Bereitstellen von Python-Lambda-Funktionen mit Container-Images
Es gibt drei Möglichkeiten, ein Container-Image für eine Python-Lambda-Funktion zu erstellen:
+ [Verwenden eines AWS Basis-Images für Python](#python-image-instructions)
Die [AWS -Basis-Images](images-create.md#runtimes-images-lp) sind mit einer Sprachlaufzeit, einem Laufzeitschnittstellen-Client zur Verwaltung der Interaktion zwischen Lambda und Ihrem Funktionscode und einem Laufzeitschnittstellen-Emulator für lokale Tests vorinstalliert.
+ [Es wird ein AWS reines Betriebssystem-Basis-Image verwendet](images-create.md#runtimes-images-provided)
[AWS Basis-Images nur für Betriebssysteme](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) sowie für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie Node.js 19. Sie können reine OS-Basis-Images auch verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für Python](#python-image-clients) in das Image aufnehmen.
+ [Verwenden Sie ein Nicht-Basis-Image AWS ](#python-image-clients)
Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für Python](#python-image-clients) in das Image aufnehmen.
**Tipp**
Um die Zeit zu reduzieren, die benötigt wird, bis Lambda-Container-Funktionen aktiv werden, siehe die Docker-Dokumentation unter [Verwenden mehrstufiger Builds](https://docs.docker.com/build/building/multi-stage/). Um effiziente Container-Images zu erstellen, folgen Sie den [Bewährte Methoden für das Schreiben von Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Auf dieser Seite wird erklärt, wie Sie Container-Images für Lambda erstellen, testen und bereitstellen.
**Topics**
+ [AWS Basisbilder für Python](#python-image-base)
+ [Verwenden eines AWS Basis-Images für Python](#python-image-instructions)
+ [Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client](#python-image-clients)
## AWS Basisbilder für Python
AWS stellt die folgenden Basis-Images für Python bereit:
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| 3.14 | Python 3.14 | Amazon Linux 2023 | [Dockerfile für Python 3.14 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.14/Dockerfile.python3.14) | 30. Juni 2029 |
| 3.13 | Python 3.13 | Amazon Linux 2023 | [Dockerfile für Python 3.13 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.13/Dockerfile.python3.13) | 30. Juni 2029 |
| 3,12 | Python 3.12 | Amazon Linux 2023 | [Dockerfile für Python 3.12 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.12/Dockerfile.python3.12) | 31. Oktober 2028 |
| 3.11 | Python 3.11 | Amazon Linux 2 | [Dockerfile für Python 3.11 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.11/Dockerfile.python3.11) | 30. Juni 2027 |
| 3,10 | Python 3.10 | Amazon Linux 2 | [Dockerfile für Python 3.10 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.10/Dockerfile.python3.10) | 31. Oktober 2026 |
Amazon ECR-Repository: [gallery.ecr. aws/lambda/python](https://gallery.ecr.aws/lambda/python)
Die Basis-Images für Python 3.12 und höher basieren auf dem [Amazon Linux 2023 Minimal Container Image](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Die Python 3.8-3.11-Basis-Images basieren auf dem Amazon Linux 2-Image. AL2023basierte Images bieten mehrere Vorteile gegenüber Amazon Linux 2, darunter einen geringeren Bereitstellungsaufwand und aktualisierte Versionen von Bibliotheken wie`glibc`.
AL2023-basierte Images verwenden `microdnf` (`dnf`symbolisiert als) als Paketmanager anstelle von`yum`, dem Standard-Paketmanager in Amazon Linux 2. `microdnf`ist eine eigenständige Implementierung von. `dnf` Eine Liste der Pakete, die in AL2023 basierten Images enthalten sind, finden Sie in den Spalten **Minimal Container** unter [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Weitere Informationen zu den Unterschieden zwischen Amazon Linux 2 AL2023 und Amazon Linux 2 finden Sie unter [Einführung in die Amazon Linux 2023 Runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) im AWS Compute-Blog.
**Anmerkung**
Um AL2023 basierte Images lokal auszuführen, auch mit AWS Serverless Application Model (AWS SAM), müssen Sie Docker-Version 20.10.10 oder höher verwenden.
### Suchpfad für Abhängigkeiten in den Basis-Images
Wenn Sie in Ihrem Code eine `import`-Anweisung verwenden, durchsucht die Python-Laufzeit die Verzeichnisse in ihrem Suchpfad, bis sie das Modul oder Paket findet. Standardmäßig durchsucht die Laufzeit zuerst das Verzeichnis `{LAMBDA_TASK_ROOT}`. Wenn Sie eine Version einer in der Laufzeit enthaltenen Bibliothek in Ihr Image einfügen, hat Ihre Version Vorrang vor der Version, die in der Laufzeit enthalten ist.
Andere Schritte im Suchpfad hängen davon ab, welche Version des Lambda-Basis-Images für Python Sie verwenden:
+ **Python 3.11 und neuer**: In der Laufzeit enthaltene Bibliotheken und über pip installierte Bibliotheken werden im Verzeichnis `/var/lang/lib/python3.11/site-packages` installiert. Dieses Verzeichnis hat im Suchpfad Vorrang vor `/var/runtime`. Sie können das SDK außer Kraft setzen, indem Sie pip verwenden, um eine neuere Version zu installieren. Sie können mithilfe von pip überprüfen, ob das in der Laufzeit enthaltene SDK und seine Abhängigkeiten mit allen Paketen kompatibel sind, die Sie installieren.
+ **Python 3.8-3.10**: In der Laufzeit enthaltene Bibliotheken werden im Verzeichnis `/var/runtime` installiert. Über pip installierte Bibliotheken werden im Verzeichnis `/var/lang/lib/python3.x/site-packages` installiert. Das Verzeichnis `/var/runtime` hat im Suchpfad Vorrang vor `/var/lang/lib/python3.x/site-packages`.
Sie können den vollständigen Suchpfad für Ihre Lambda-Funktion sehen, indem Sie den folgenden Codeausschnitt hinzufügen.
```
import sys
search_path = sys.path
print(search_path)
```
## Verwenden eines AWS Basis-Images für Python
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Python
### Erstellen eines Images aus einem Base Image
**So erstellen Sie ein Container-Image aus einem AWS Basis-Image für Python**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie eine neue Datei mit dem Namen `lambda_function.py`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example Python-Funktion**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Erstellen Sie eine neue Datei mit dem Namen `requirements.txt`. Wenn Sie den Beispielfunktionscode aus dem vorherigen Schritt verwenden, können Sie die Datei leer lassen, da es keine Abhängigkeiten gibt. Andernfalls listen Sie jede benötigte Bibliothek auf. So sollte beispielsweise Ihre `requirements.txt` aussehen, wenn Ihre Funktion AWS SDK für Python (Boto3) verwendet:
**Example requirements.txt**
```
boto3
```
1. Erstellen Sie eine neue Docker-Datei mit der folgenden Konfiguration:
+ Setzen Sie die `FROM`-Eigenschaft auf den [URI des Basis-Images](https://gallery.ecr.aws/lambda/python/).
+ Verwenden Sie den Befehl COPY, um den Funktionscode und die Laufzeitabhängigkeiten in `{LAMBDA_TASK_ROOT}`, eine von [Lambda definierte Umgebungsvariable](configuration-envvars.md#configuration-envvars-runtime) zu kopieren.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/python:3.12
# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}
# Install the specified packages
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.handler" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. In diesem Beispiel ist `docker-image` der Image-Name und `test` der Tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie stattdessen die `--platform linux/arm64` Option verwenden. `--platform linux/amd64`
1. Veröffentlichen Sie in einem neuen Terminalfenster ein Ereignis an den lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
Wenn Sie ein [OS-Basis-Image](images-create.md#runtimes-images-provided) oder ein alternatives Basis-Image verwenden, müssen Sie den Laufzeitschnittstellen-Client in das Image einbinden. Der Laufzeitschnittstellen-Client erweitert die [Laufzeit-API](runtimes-api.md), die die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet.
Installieren Sie den [Laufzeitschnittstellen-Client für Python](https://pypi.org/project/awslambdaric) mit dem pip-Paketmanager:
```
pip install awslambdaric
```
Sie können den [Python-Runtime-Interface-Client](https://github.com/aws/aws-lambda-python-runtime-interface-client/) auch von herunterladen GitHub.
Das folgende Beispiel zeigt, wie ein Container-Image für Python mit einem AWS Nicht-Base-Image erstellt wird. Das Beispiel-Dockerfile verwendet ein offizielles Python-Basis-Image. Das Dockerfile enthält den Laufzeitschnittstellen-Client für Python.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Python
### Erstellen eines Images aus einem alternativen Basis-Image
**Um ein Container-Image aus einem AWS Nicht-Basis-Image zu erstellen**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie eine neue Datei mit dem Namen `lambda_function.py`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example Python-Funktion**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Erstellen Sie eine neue Datei mit dem Namen `requirements.txt`. Wenn Sie den Beispielfunktionscode aus dem vorherigen Schritt verwenden, können Sie die Datei leer lassen, da es keine Abhängigkeiten gibt. Andernfalls listen Sie jede benötigte Bibliothek auf. So sollte beispielsweise Ihre `requirements.txt` aussehen, wenn Ihre Funktion AWS SDK für Python (Boto3) verwendet:
**Example requirements.txt**
```
boto3
```
1. Erstellen Sie eine neue Docker-Datei. Das folgende Dockerfile verwendet ein offizielles Python-Basis-Image anstelle eines [AWS -Basis-Images](images-create.md#runtimes-images-lp). Das Dockerfile enthält den [Laufzeitschnittstellen-Client](https://pypi.org/project/awslambdaric), der das Image mit Lambda kompatibel macht. Die folgende Beispiel-Docker-Datei verwendet eine [mehrstufige Entwicklung](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds).
+ Legen Sie die `FROM`-Eigenschaft auf das Basis-Image fest.
+ Legen Sie `ENTRYPOINT` auf das Modul fest, das der Docker-Container beim Start ausführen soll. In diesem Fall ist das Modul der Laufzeitschnittstellen-Client.
+ Legen Sie `CMD` auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM python:3.12 AS build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
# Install the function's dependencies
RUN pip install \
--target ${FUNCTION_DIR} \
awslambdaric
# Use a slim version of the base Python image to reduce the final image size
FROM python:3.12-slim
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "lambda_function.handler" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
Verwenden Sie den [Laufzeit-Schnittstellen-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/), um das Image lokal zu testen. Sie können [den Emulator in Ihr Image integrieren](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) oder ihn mit dem folgenden Verfahren auf Ihrem lokalen Computer installieren.
**Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer**
1. Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Um den arm64-Emulator zu installieren, ersetzen Sie die GitHub Repository-URL im vorherigen Befehl durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Um den arm64-Emulator zu installieren, ersetzen Sie das `$downloadLink` durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. Beachten Sie Folgendes:
+ `docker-image` ist der Image-Name und `test` ist das Tag.
+ `/usr/local/bin/python -m awslambdaric lambda_function.handler` ist der `ENTRYPOINT` gefolgt von dem `CMD` aus Ihrem Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie die `--platform linux/arm64` Option anstelle von verwenden. `--platform linux/amd64`
1. Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
Ein Beispiel für das Erstellen eines Python-Images aus einem Alpine-Basis-Image finden Sie unter [Unterstützung für Container-Images für Lambda](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-container-image-support/) im AWS Blog.
# Arbeiten mit Ebenen für Python Lambda-Funktionen
Verwenden Sie [Lambda-Ebenen](chapter-layers.md), um Code und Abhängigkeiten zu bündeln, die Sie für mehrere Funktionen wiederverwenden möchten. Ebenen enthalten üblicherweise Bibliotheksabhängigkeiten, eine [benutzerdefinierte Laufzeit](runtimes-custom.md) oder Konfigurationsdateien. Das Erstellen einer Ebene umfasst drei allgemeine Schritte:
1. Verpacken Ihres Ebeneninhalts. Dies bedeutet, dass Sie ein .zip-Dateiarchiv erstellen, das die Abhängigkeiten enthält, die Sie in Ihren Funktionen verwenden möchten.
1. Erstellen Sie die Ebene in Lambda.
1. Fügen Sie die Ebene zu Ihren Funktionen hinzu.
**Topics**
+ [Verpacken Ihres Ebeneninhalts](#python-layers-package)
+ [Erstellen Sie die Ebene in Lambda](#publishing-layer)
+ [Fügen Sie die Ebene zu Ihrer Funktion hinzu](#python-layer-adding)
+ [Beispiel-App](#python-layer-sample-app)
## Verpacken Ihres Ebeneninhalts
Um eine Ebene zu erstellen, bündeln Sie Ihre Pakete in einem ZIP-Dateiarchiv, das die folgenden Anforderungen erfüllt:
+ Erstellen Sie die Ebene mithilfe derselben Version von Python, die Sie für die Lambda-Funktion verwenden möchten. Wenn Sie Ihren Layer beispielsweise mit Python 3.14 erstellen, verwenden Sie die Python 3.14-Laufzeit für Ihre Funktion.
+ Ihre ZIP-Datei muss ein `python`-Verzeichnis auf der Stammebene enthalten.
+ Die Pakete in Ihrer Ebene müssen mit Linux kompatibel sein. Lambda-Funktionen werden auf Amazon Linux ausgeführt.
Sie können Ebenen erstellen, die entweder mit `pip` installierte Python-Bibliotheken von Drittanbietern (wie `requests` oder `pandas`) oder Ihre eigenen Python-Module und -Pakete enthalten.
### Abhängigkeiten von Drittanbietern
**So erstellen Sie eine Ebene mit pip-Paketen**
1. Wählen Sie eine der folgenden Methoden, um `pip`-Pakete in das erforderliche Verzeichnis der obersten Ebene (`python/`) zu installieren:
------
#### [ pip install ]
Für reine Python-Pakete (wie Anfragen oder boto3):
```
pip install requests -t python/
```
Einige Python-Pakete, wie NumPy Pandas, enthalten kompilierte C-Komponenten. Wenn Sie eine Ebene mit diesen Paketen unter macOS oder Windows erstellen, müssen Sie möglicherweise diesen Befehl verwenden, um ein Linux-kompatibles Wheel zu installieren:
```
pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Weitere Informationen zur Arbeit mit Python-Paketen, die kompilierte Komponenten enthalten, finden Sie unter [ZIP-Bereitstellungspakete mit nativen Bibliotheken erstellen](python-package.md#python-package-native-libraries).
------
#### [ requirements.txt ]
Mithilfe einer `requirements.txt`-Datei können Sie Paketversionen verwalten und konsistente Installationen sicherstellen.
**Example requirements.txt**
```
requests==2.31.0
boto3==1.37.34
numpy==1.26.4
```
Wenn Ihre `requirements.txt`-Datei nur reine Python-Pakete enthält (wie Anfragen oder boto3):
```
pip install -r requirements.txt -t python/
```
Einige Python-Pakete, wie NumPy Pandas, enthalten kompilierte C-Komponenten. Wenn Sie eine Ebene mit diesen Paketen unter macOS oder Windows erstellen, müssen Sie möglicherweise diesen Befehl verwenden, um ein Linux-kompatibles Wheel zu installieren:
```
pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
```
Weitere Informationen zur Arbeit mit Python-Paketen, die kompilierte Komponenten enthalten, finden Sie unter [ZIP-Bereitstellungspakete mit nativen Bibliotheken erstellen](python-package.md#python-package-native-libraries).
------
1. Zippen Sie den Inhalt des `python`-Verzeichnisses.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:
```
python/ # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```
**Anmerkung**
Wenn Sie eine virtuelle Python-Umgebung (venv) zur Installation von Paketen verwenden, sieht Ihre Verzeichnisstruktur anders aus (zum Beispiel `python/lib/python3.x/site-packages`). Solange Ihre ZIP-Datei das `python`-Verzeichnis auf der Stammebene enthält, kann Lambda Ihre Pakete finden und importieren.
### Benutzerdefinierte Python-Module
**So erstellen Sie eine Ebene mithilfe Ihres eigenen Codes**
1. Erstellen Sie das erforderliche Verzeichnis der obersten Ebene für Ihre Ebene:
```
mkdir python
```
1. Erstellen Sie Ihre Python-Module im `python`-Verzeichnis. Das folgende Beispielmodul validiert Bestellungen, indem es überprüft, ob sie die erforderlichen Informationen enthalten.
**Example Benutzerdefiniertes Modul: validator.py**
```
import json
def validate_order(order_data):
"""Validates an order and returns formatted data."""
required_fields = ['product_id', 'quantity']
# Check required fields
missing_fields = [field for field in required_fields if field not in order_data]
if missing_fields:
raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
# Validate quantity
quantity = order_data['quantity']
if not isinstance(quantity, int) or quantity < 1:
raise ValueError("Quantity must be a positive integer")
# Format and return the validated data
return {
'product_id': str(order_data['product_id']),
'quantity': quantity,
'shipping_priority': order_data.get('priority', 'standard')
}
def format_response(status_code, body):
"""Formats the API response."""
return {
'statusCode': status_code,
'body': json.dumps(body)
}
```
1. Zippen Sie den Inhalt des `python`-Verzeichnisses.
------
#### [ Linux/macOS ]
```
zip -r layer.zip python/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\python -DestinationPath .\layer.zip
```
------
Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:
```
python/ # Required top-level directory
└── validator.py
```
1. Importieren und verwenden Sie die Module in Ihrer Funktion wie bei jedem anderen Python-Paket. Beispiel:
```
from validator import validate_order, format_response
import json
def lambda_handler(event, context):
try:
# Parse the order data from the event body
order_data = json.loads(event.get('body', '{}'))
# Validate and format the order
validated_order = validate_order(order_data)
return format_response(200, {
'message': 'Order validated successfully',
'order': validated_order
})
except ValueError as e:
return format_response(400, {
'error': str(e)
})
except Exception as e:
return format_response(500, {
'error': 'Internal server error'
})
```
Sie können das folgende [Testereignis](testing-functions.md#invoke-with-event) verwenden, um die Funktion aufzurufen:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Erwartete Antwort:
```
{
"statusCode": 200,
"body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}"
}
```
## Erstellen Sie die Ebene in Lambda
Sie können Ihren Layer entweder mit der AWS CLI oder der Lambda-Konsole veröffentlichen.
------
#### [ AWS CLI ]
Führen Sie den [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI Befehl aus, um die Lambda-Schicht zu erstellen:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes python3.14
```
Der Parameter [Kompatible Laufzeiten](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) ist optional. Wenn angegeben, verwendet Lambda diesen Parameter zum Filtern von Ebenen in der Lambda-Konsole.
------
#### [ Console ]
**So erstellen Sie eine Ebene (Konsole)**
1. Öffnen Sie die Seite [Ebenen](https://console.aws.amazon.com/lambda/home#/layers) der Lambda-Konsole.
1. Wählen Sie **Create Layer (Ebene erstellen)** aus.
1. Wählen Sie **ZIP-Datei hochladen** und laden Sie dann das zuvor erstellte ZIP-Archiv hoch.
1. (Optional) Wählen Sie für **Kompatible Laufzeiten** die Python-Laufzeit aus, die der Python-Version entspricht, mit der Sie die Ebene erstellt haben.
1. Wählen Sie **Erstellen** aus.
------
## Fügen Sie die Ebene zu Ihrer Funktion hinzu
------
#### [ AWS CLI ]
Führen Sie den [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI Befehl aus, um die Ebene an Ihre Funktion anzuhängen. Verwenden Sie den ARN der Ebene für den `--layers`-Parameter. Der ARN muss die Version angeben (z. B. `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Weitere Informationen finden Sie unter [Ebenen und Ebenenversionen](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
------
#### [ Console ]
**So fügen Sie eine Ebene zu einer Funktion hinzu**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus.
1. Blättern Sie nach unten bis zum Abschnitt **Ebenen** und wählen Sie dann **Eine Ebene hinzufügen**.
1. Wählen Sie unter **Ebene auswählen** die Option **Benutzerdefinierte Ebenen** und dann Ihre Ebene aus.
**Anmerkung**
Wenn Sie bei der Erstellung der Ebene keine [kompatible Laufzeit](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) hinzugefügt haben, wird die Ebene hier nicht aufgeführt. Sie können stattdessen den ARN der Ebene angeben.
1. Wählen Sie **Hinzufügen** aus.
------
## Beispiel-App
Weitere Beispiele für die Verwendung von Lambda-Layern finden Sie in der [Layer-Python-Beispielanwendung](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-python) im AWS Lambda Developer Guide-Repository. GitHub Diese Anwendung umfasst zwei Ebenen, die Python-Bibliotheken enthalten. Nach dem Erstellen der Ebenen können Sie die entsprechende Funktionen bereitstellen und aufrufen, um zu bestätigen, dass die Ebenen wie erwartet funktionieren.
# Verwenden des Lambda-Kontextobjekts zum Abrufen von Python-Funktionsinformationen
Wenn Lambda Ihre Funktion ausführt, wird ein Context-Objekt an den [Handler](python-handler.md). übergeben. Dieses Objekt stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereit. Weitere Informationen darüber, wie das Kontextobjekt an den Funktions-Handler übergeben wird, finden Sie unter [Lambda-Funktionshandler in Python definieren](python-handler.md).
**Context-Methoden**
+ `get_remaining_time_in_millis` – Gibt die Anzahl der verbleibenden Millisekunden zurück, bevor die Ausführung das Zeitlimit überschreitet.
**Context-Eigenschaften**
+ `function_name` – Der Name der Lambda-Funktion.
+ `function_version` – Die [Version](configuration-versions.md) der Funktion.
+ `invoked_function_arn` – Der Amazon-Ressourcenname (ARN), der zum Aufrufen der Funktion verwendet wird. Gibt an, ob der Aufrufer eine Versionsnummer oder einen Alias angegeben hat.
+ `memory_limit_in_mb` – Die Menge an Arbeitsspeicher, die der Funktion zugewiesen ist.
+ `aws_request_id` – Der Bezeichner der Aufrufanforderung.
+ `log_group_name` – Protokollgruppe für die Funktion.
+ `log_stream_name` – Der Protokollstream für die Funktions-Instance.
+ `identity` – Informationen zur Amazon-Cognito-Identität, die die Anforderung autorisiert hat.
+ `cognito_identity_id`— Die authentifizierte Amazon-Cognito-Identität.
+ `cognito_identity_pool_id` – Der Amazon-Cognito-Identitätspool, der den Aufruf autorisiert hat.
+ `client_context` – (mobile Apps) Clientkontext, der Lambda von der Clientanwendung bereitgestellt wird.
+ `client.installation_id`
+ `client.app_title`
+ `client.app_version_name`
+ `client.app_version_code`
+ `client.app_package_name`
+ `custom` – Ein `dict` mit benutzerdefinierten Werten, die von der mobilen Clientanwendung festgelegt wurden.
+ `env` – Ein `dict` mit Umgebungsinformationen, die vom AWS SDK bereitgestellt wurden.
Powertools für Lambda (Python) bietet eine Schnittstellendefinition für das Lambda-Kontextobjekt. Sie können die Schnittstellendefinition für Typhinweise verwenden oder die Struktur des Lambda-Kontextobjekts genauer untersuchen. Die Schnittstellendefinition finden Sie unter [lambda\$1context.py](https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/utilities/typing/lambda_context.py) im *powertools-lambda-python* auf GitHub.
Das folgende Beispiel zeigt eine Handler-Funktion zur Protokollierung von Context-Informationen.
**Example handler.py**
```
import time
def lambda_handler(event, context):
print("Lambda function ARN:", context.invoked_function_arn)
print("CloudWatch log stream name:", context.log_stream_name)
print("CloudWatch log group name:", context.log_group_name)
print("Lambda Request ID:", context.aws_request_id)
print("Lambda function memory limits in MB:", context.memory_limit_in_mb)
# We have added a 1 second delay so you can see the time remaining in get_remaining_time_in_millis.
time.sleep(1)
print("Lambda time remaining in MS:", context.get_remaining_time_in_millis())
```
Zusätzlich zu den oben aufgeführten Optionen können Sie das AWS X-Ray-SDK für [Instrumentierung von Python-Code in AWS Lambda](python-tracing.md) zudem verwenden, um kritische Code-Pfade zu identifizieren, deren Leistung nachzuverfolgen und die Daten für die Analyse zu erfassen.
# Python-Lambda-Funktionen protokollieren und überwachen
AWS Lambda überwacht automatisch Lambda-Funktionen und sendet Protokolleinträge an Amazon CloudWatch. Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen zu CloudWatch Logs finden Sie unter[Senden von Lambda-Funktionsprotokollen an CloudWatch Logs](monitoring-cloudwatchlogs.md).
Zur Ausgabe von Protokollen aus Ihrem Funktionscode können Sie das integrierte [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html)-Modul verwenden. Für detailliertere Einträge können Sie jede Protokollierungsbibliothek verwenden, die in `stdout` oder `stderr` schreibt.
## Ausdrucken in das Protokoll
Um eine grundlegende Ausgabe an die Protokolle zu senden, können Sie in Ihrer Funktion eine `print`-Methode verwenden. Im folgenden Beispiel werden die Werte der CloudWatch Loggruppe und des Streams Logs sowie das Event-Objekt protokolliert.
Beachten Sie, dass Lambda Protokollausgaben nur im Klartextformat an Logs senden kann, wenn Ihre Funktion CloudWatch Logs mithilfe von `print` Python-Anweisungen ausgibt. Um Protokolle in strukturiertem JSON zu erfassen, müssen Sie eine unterstützte Protokollierungsbibliothek verwenden. Weitere Informationen finden Sie unter [Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python](#python-logging-advanced).
**Example lambda\$1function.py**
```
import os
def lambda_handler(event, context):
print('## ENVIRONMENT VARIABLES')
print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
print('## EVENT')
print(event)
```
**Example Protokollausgabe**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Die Python-Laufzeit protokolliert die Zeilen `START`, `END` und `REPORT` für jeden Aufruf. Die `REPORT`-Zeile enthält die folgenden Daten:
**Datenfelder für REPORT-Zeilen**
+ **RequestId**— Die eindeutige Anforderungs-ID für den Aufruf.
+ **Dauer** – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.
+ **Fakturierte Dauer** – Die für den Aufruf fakturierte Zeit.
+ **Speichergröße** – Die der Funktion zugewiesene Speichermenge.
+ **Max. verwendeter Speicher** – Die Speichermenge, die von der Funktion verwendet wird. Wenn Aufrufe eine Ausführungsumgebung gemeinsam nutzen, meldet Lambda den maximalen Speicherverbrauch für alle Aufrufe. Dieses Verhalten kann zu einem höheren als erwarteten gemeldeten Wert führen.
+ **Initialisierungsdauer** – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.
+ **XRAY TraceId** [— Für verfolgte Anfragen die AWS X-Ray Trace-ID.](services-xray.md)
+ **SegmentId**— Für verfolgte Anfragen die X-Ray-Segment-ID.
+ **Stichprobe** – Bei verfolgten Anforderungen das Stichprobenergebnis.
## Verwendung einer Protokollierungsbibliothek
Für detailliertere Protokolle verwenden Sie das Modul zur [Protokollierung](https://docs.python.org/3/library/logging.html) in der Standardbibliothek oder eine beliebige Protokollierungsbibliothek eines Drittanbieters, die in `stdout` oder `stderr` schreibt.
Für unterstützte Python-Laufzeiten können Sie wählen, ob mit dem `logging`-Standardmodul erstellte Protokolle im Klartext oder in JSON erfasst werden. Weitere Informationen hierzu finden Sie unter [Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python](#python-logging-advanced).
Derzeit ist das Standard-Protokollformat für alle Python-Laufzeiten das Klartextformat. Das folgende Beispiel zeigt, wie Protokollausgaben, die mit dem `logging` Standardmodul erstellt wurden, im Klartext in CloudWatch Logs erfasst werden.
```
import os
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES')
logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
logger.info('## EVENT')
logger.info(event)
```
Die Ausgabe aus `logger` umfasst die Protokollebene, den Zeitstempel und die Anforderungs-ID.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 /aws/lambda/my-function
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
**Anmerkung**
Wenn das Protokollformat Ihrer Funktion auf Klartext gesetzt ist, lautet die Standardeinstellung auf Protokollebene für Python-Laufzeiten WARN. Das bedeutet, dass Lambda nur Protokollausgaben der Stufe WARN und niedriger an CloudWatch Logs sendet. Um die Standardprotokollebene zu ändern, verwenden Sie die Python-Methode `logging` `setLevel()`, wie in diesem Beispielcode gezeigt. Wenn Sie das Protokollformat Ihrer Funktion auf JSON setzen, empfehlen wir, die Protokollebene der Funktion mithilfe der erweiterten Lambda Advanced Logging Controls zu konfigurieren und nicht die Protokollebene im Code festzulegen. Weitere Informationen hierzu finden Sie unter [Verwenden der Filterung auf Protokollebene mit Python](#python-logging-levels).
## Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python
Um Ihnen mehr Kontrolle darüber zu geben, wie die Protokolle Ihrer Funktionen erfasst, verarbeitet und verwendet werden, können Sie die folgenden Protokollierungsoptionen für unterstützte Lambda-Python-Laufzeiten konfigurieren:
+ **Protokollformat** – Wählen Sie zwischen Klartext und einem strukturierten JSON-Format für die Protokolle Ihrer Funktion aus.
+ **Protokollebene** — für Logs im JSON-Format wählen Sie die Detailebene der Logs, die Lambda an Amazon sendet CloudWatch, wie ERROR, DEBUG oder INFO
+ **Protokollgruppe** — wählen Sie die CloudWatch Protokollgruppe aus, an die Ihre Funktion Protokolle sendet
Weitere Informationen zu diesen Protokollierungsoptionen und Anweisungen zur Konfiguration Ihrer Funktion für deren Verwendung finden Sie unter [Konfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
Weitere Informationen zur Verwendung der Optionen für das Protokollformat und die Protokollebene mit Ihren Python-Lambda-Funktionen finden Sie in den folgenden Abschnitten.
### Verwenden strukturierter JSON-Protokolle mit Python
Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die von der Python-Standard-Logging-Bibliothek ausgegebenen Logs CloudWatch als strukturiertes JSON an. Jedes JSON-Protokollobjekt enthält mindestens vier Schlüssel-Wert-Paare mit den folgenden Schlüsseln:
+ `"timestamp"` – die Uhrzeit, zu der die Protokollmeldung generiert wurde
+ `"level"` – die der Meldung zugewiesene Protokollebene
+ `"message"` – der Inhalt der Protokollmeldung
+ `"requestId"` – die eindeutige Anforderungs-ID für den Funktionsaufruf
Die `logging`-Bibliothek von Python kann auch zusätzliche Schlüssel-Wert-Paare wie `"logger"` zu diesem JSON-Objekt hinzufügen.
Die Beispiele in den folgenden Abschnitten zeigen, wie mit der `logging` Python-Bibliothek generierte Protokollausgaben in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion als JSON konfigurieren.
Beachten Sie Folgendes: Wenn Sie die `print`-Methode verwenden, um grundlegende Protokollausgaben zu erzeugen, wie unter [Ausdrucken in das Protokoll](#python-logging-output) beschrieben, erfasst Lambda diese Ausgaben als Klartext, auch wenn Sie das Protokollierungsformat Ihrer Funktion als JSON konfigurieren.
#### Standard-JSON-Protokollausgaben mithilfe der Python-Protokollierungsbibliothek
Der folgende Beispielcodeausschnitt und die Protokollausgabe zeigen, wie mit der `logging` Python-Bibliothek generierte Standardprotokollausgaben in CloudWatch Logs erfasst werden, wenn das Protokollformat Ihrer Funktion auf JSON gesetzt ist.
**Example Python-Protokollierungscode**
```
import logging
logger = logging.getLogger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp":"2025-10-27T19:17:45.586Z",
"level":"INFO",
"message":"Inside the handler function",
"logger": "root",
"requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}
```
#### Protokollieren zusätzlicher Parameter in JSON
Wenn das Protokollformat Ihrer Funktion auf JSON eingestellt ist, können Sie auch zusätzliche Parameter mit der standardmäßigen Python `logging`-Bibliothek protokollieren, indem Sie das Schlüsselwort `extra` verwenden, um ein Python-Wörterbuch an die Protokollausgabe zu übergeben.
**Example Python-Protokollierungscode**
```
import logging
def lambda_handler(event, context):
logging.info(
"extra parameters example",
extra={"a":"b", "b": [3]},
)
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp": "2025-11-02T15:26:28Z",
"level": "INFO",
"message": "extra parameters example",
"logger": "root",
"requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
"a": "b",
"b": [
3
]
}
```
#### Protokollierungsausnahmen in JSON
Der folgende Codeausschnitt zeigt, wie Python-Ausnahmen in der Protokollausgabe Ihrer Funktion erfasst werden, wenn Sie das Protokollformat als JSON konfigurieren. Beachten Sie, dass den mit `logging.exception` generierten Protokollausgaben die Protokollebene ERROR zugewiesen wird.
**Example Python-Protokollierungscode**
```
import logging
def lambda_handler(event, context):
try:
raise Exception("exception")
except:
logging.exception("msg")
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp": "2025-11-02T16:18:57Z",
"level": "ERROR",
"message": "msg",
"logger": "root",
"stackTrace": [
" File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n raise Exception(\"exception\")\n"
],
"errorType": "Exception",
"errorMessage": "exception",
"requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
"location": "/var/task/lambda_function.py:lambda_handler:17"
}
```
#### Strukturierte JSON-Protokolle mit anderen Protokollierungstools
Wenn Ihr Code bereits eine andere Logging-Bibliothek wie Powertools for verwendet AWS Lambda, um strukturierte JSON-Logs zu erstellen, müssen Sie keine Änderungen vornehmen. AWS Lambda codiert keine Logs doppelt, die bereits JSON-kodiert sind. Selbst wenn Sie Ihre Funktion so konfigurieren, dass sie das JSON-Protokollformat verwendet, erscheinen Ihre Logging-Ausgaben CloudWatch in der von Ihnen definierten JSON-Struktur.
Das folgende Beispiel zeigt, wie Protokollausgaben, die mit dem AWS Lambda Paket Powertools for generiert wurden, in CloudWatch Logs erfasst werden. Das Format dieser Protokollausgabe ist dasselbe, unabhängig davon, ob die Protokollierungskonfiguration Ihrer Funktion auf JSON oder TEXT festgelegt ist. Weitere Informationen zur Verwendung von Powertools für finden Sie unter AWS Lambda und [Verwendung von Powertools für AWS Lambda (Python) und AWS SAM für strukturiertes Logging](#python-logging-sam) [Verwendung von Powertools für AWS Lambda (Python) und AWS CDK für strukturiertes Logging](#python-logging-powertools-cdk)
**Example Codeausschnitt für die Python-Protokollierung (mit Powertools für) AWS Lambda**
```
from aws_lambda_powertools import Logger
logger = Logger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example JSON-Protokolldatensatz (unter Verwendung von Powertools für) AWS Lambda**
```
{
"level": "INFO",
"location": "lambda_handler:7",
"message": "Inside the handler function",
"timestamp": "2025-10-31 22:38:21,010+0000",
"service": "service_undefined",
"xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30"
}
```
### Verwenden der Filterung auf Protokollebene mit Python
Durch die Konfiguration der Filterung auf Protokollebene können Sie festlegen, dass nur Protokolle mit einer bestimmten Protokollierungsebene oder niedriger an Logs gesendet werden. CloudWatch Informationen zur Konfiguration der Filterung auf Protokollebene für Ihre Funktion finden Sie unter [Filterung auf Protokollebene](monitoring-cloudwatchlogs-log-level.md).
AWS Lambda Um Ihre Anwendungsprotokolle nach ihrer Protokollebene zu filtern, muss Ihre Funktion Protokolle im JSON-Format verwenden. Sie können dies auf zwei Arten erreichen:
+ Erstellen Sie Protokollausgaben mit der `logging`-Python-Standardbibliothek und konfigurieren Sie Ihre Funktion so, dass sie die JSON-Protokollformatierung verwendet. AWS Lambda filtert dann Ihre Protokollausgaben mithilfe des Schlüssel-Wert-Paars „level“ im JSON-Objekt, wie unter [Verwenden strukturierter JSON-Protokolle mit Python](#python-logging-JSON) beschrieben. Informationen zur Konfiguration des Protokollformats Ihrer Funktion finden Sie unter [Konfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
+ Verwenden Sie eine andere Protokollierungsbibliothek oder Methode, um strukturierte JSON-Protokolle in Ihrem Code zu erstellen, die ein „level“-Schlüssel-Wert-Paar enthalten, das die Ebene der Protokollausgabe definiert. Sie können Powertools beispielsweise verwenden, AWS Lambda um strukturierte JSON-Protokollausgaben aus Ihrem Code zu generieren.
Sie können auch eine „print“-Anweisung verwenden, um ein JSON-Objekt auszugeben, das eine Protokollebenenkennung enthält. Die folgende Print-Anweisung erzeugt eine Ausgabe im JSON-Format, bei der die Protokollebene auf INFO gesetzt ist. AWS Lambda sendet das JSON-Objekt an CloudWatch Logs, wenn die Protokollierungsebene Ihrer Funktion auf INFO, DEBUG oder TRACE gesetzt ist.
```
print('{"msg":"My log message", "level":"info"}')
```
Damit Lambda die Protokolle Ihrer Funktion filtern kann, müssen Sie auch ein `"timestamp"`-Schlüssel-Wert-Paar in Ihre JSON-Protokollausgabe aufnehmen. Die Uhrzeit muss im gültigen [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt)-Zeitstempelformat angegeben werden. Wenn Sie keinen gültigen Zeitstempel angeben, weist Lambda dem Protokoll die Stufe INFO zu und fügt einen Zeitstempel für Sie hinzu.
## Anzeigen von Protokollen in der Lambda-Konsole
Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.
Wenn Ihr Code über den eingebetteten **Code**-Editor getestet werden kann, finden Sie Protokolle in den **Ausführungsergebnissen**. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die **Protokollausgabe** im Abschnitt **Details**.
## Logs in CloudWatch der Konsole anzeigen
Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufe anzuzeigen.
**Um Protokolle auf der Konsole anzuzeigen CloudWatch**
1. Öffnen Sie die [Seite Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home?#logs:) auf der CloudWatch Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (***your-function-name*/aws/lambda/**).
1. Wählen Sie eine Protokollstream aus.
Jeder Protokoll-Stream entspricht einer [Instance Ihrer Funktion](lambda-runtime-environment.md). Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instanzen für gleichzeitige Aufrufe erstellt werden. Um Protokolle für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.
## Logs anzeigen mit AWS CLI
Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) verwenden, um Protokolle für einen Aufruf mit der `--log-type`-Befehlsoption abzurufen. Die Antwort enthält das Feld `LogResult`, das bis zu 4 KB base64-verschlüsselte Protokolle aus dem Aufruf enthält.
**Example eine Log-ID abrufen**
Das folgende Beispiel zeigt, wie eine *Protokoll-ID* aus dem `LogResult`-Feld für eine Funktion namens `my-function` abgerufen wird.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example entschlüsseln der Protokolle**
Verwenden Sie in derselben Eingabeaufforderung das `base64`-Dienstprogramm, um die Protokolle zu entschlüsseln. Das folgende Beispiel zeigt, wie Base64-codierte Logs für abgerufen werde `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
Die Ausgabe sollte folgendermaßen aussehen:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
Das `base64`-Dienstprogramm ist unter Linux, macOS und [Ubuntu auf Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10)verfügbar. macOS-Benutzer müssen möglicherweise `base64 -D` verwenden.
**Example get-logs.sh-Skript**
Verwenden Sie in derselben Eingabeaufforderung das folgende Skript, um die letzten fünf Protokollereignisse herunterzuladen. Das Skript verwendet `sed` zum Entfernen von Anführungszeichen aus der Ausgabedatei und wechselt 15 Sekunden lang in den Ruhezustand, um Zeit einzuräumen, damit Protokolle verfügbar werden können. Die Ausgabe enthält die Antwort von Lambda und die `get-log-events`Ausgabe des Befehls.
Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es in Ihrem Lambda-Projektverzeichnis unter `get-logs.sh`.
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS und Linux (nur diese Systeme)**
In derselben Eingabeaufforderung müssen macOS- und Linux-Benutzer möglicherweise den folgenden Befehl ausführen, um sicherzustellen, dass das Skript ausführbar ist.
```
chmod -R 755 get-logs.sh
```
**Example die letzten fünf Protokollereignisse abrufen**
Führen Sie an derselben Eingabeaufforderung das folgende Skript aus, um die letzten fünf Protokollereignisse abzurufen.
```
./get-logs.sh
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Löschen von Protokollen
Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um das unbegrenzte Speichern von Protokollen zu vermeiden, löschen Sie die Protokollgruppe oder [konfigurieren Sie eine Aufbewahrungszeitraum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) nach dem Protokolle automatisch gelöscht werden.
## Andere Tools und Bibliotheken für die Protokollierung verwenden
[Powertools for AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/) ist ein Entwickler-Toolkit zur Implementierung serverloser Best Practices und zur Steigerung der Entwicklergeschwindigkeit. Das [Logger-Serviceprogramm](https://docs.aws.amazon.com/powertools/python/latest/core/logger/) bietet einen für Lambda optimierten Logger, der zusätzliche Informationen über den Funktionskontext all Ihrer Funktionen enthält, wobei die Ausgabe als JSON strukturiert ist. Mit diesem Serviceprogramm können Sie Folgendes tun:
+ Erfassung von Schlüsselfeldern aus dem Lambda-Kontext, Kaltstart und Strukturen der Protokollierungsausgabe als JSON
+ Protokollieren Sie Ereignisse von Lambda-Aufrufen, wenn Sie dazu aufgefordert werden (standardmäßig deaktiviert)
+ Alle Protokolle nur für einen bestimmten Prozentsatz der Aufrufe über Protokollstichproben drucken (standardmäßig deaktiviert)
+ Fügen Sie dem strukturierten Protokoll zu einem beliebigen Zeitpunkt zusätzliche Schlüssel hinzu
+ Verwenden Sie einen benutzerdefinierten Protokollformatierer (Bring Your Own Formatter), um Protokolle in einer Struktur auszugeben, die mit dem Logging RFC Ihres Unternehmens kompatibel ist
## Verwendung von Powertools für AWS Lambda (Python) und AWS SAM für strukturiertes Logging
Führen Sie die nachstehenden Schritte aus, um eine Hello-World-Python-Beispielanwendung mit integrierten [-Powertools for Python](https://docs.aws.amazon.com/powertools/python/latest/)-Modulen unter Verwendung von AWS SAM bereitzustellen. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Python 3.9
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS SAM Beispielanwendung bereit**
1. Initialisieren Sie die Anwendung mit der Hello World Python-Vorlage.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing
```
1. Entwickeln Sie die App.
```
cd sam-app && sam build
```
1. Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
**Anmerkung**
Für ist **HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung?** , stellen Sie sicher, dass Sie eintreten`y`.
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl GET
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html) aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter [Arbeiten mit Protokollen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) im *AWS Serverless Application Model -Entwicklerhandbuch*.
```
sam logs --stack-name sam-app
```
Das Ergebnis sieht folgendermaßen aus:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
### Verwalten der Protokollaufbewahrung
Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um zu vermeiden, dass Protokolle auf unbestimmte Zeit gespeichert werden, löschen Sie die Protokollgruppe oder konfigurieren Sie einen Aufbewahrungszeitraum, nach dessen Ablauf die Protokolle CloudWatch automatisch gelöscht werden. Um die Aufbewahrung von Protokollen einzurichten, fügen Sie Ihrer AWS SAM Vorlage Folgendes hinzu:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
# Omitting other properties
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
RetentionInDays: 7
```
## Verwendung von Powertools für AWS Lambda (Python) und AWS CDK für strukturiertes Logging
Gehen Sie wie folgt vor, um eine Hello World Python-Beispielanwendung mit integrierten [Powertools for AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/latest/) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu den AWS CDK. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine Hello-World-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Python 3.9
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS CDK Beispielanwendung bereit**
1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
1. Initialisieren Sie die App.
```
cdk init app --language python
```
1. Installieren Sie die Python-Abhängigkeiten.
```
pip install -r requirements.txt
```
1. Erstellen Sie ein Verzeichnis **lambda\$1function** unter dem Stammordner.
```
mkdir lambda_function
cd lambda_function
```
1. Erstellen Sie eine Datei namens **app.py** und fügen Sie den folgenden Code zur Datei hinzu. Dies ist der Code für die Lambda-Funktion.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Öffnen Sie das Verzeichnis **hello\$1world**. Sie sollten eine Datei mit dem Namen **hello\$1world\$1stack.py** sehen.
```
cd ..
cd hello_world
```
1. Öffnen Sie **hello\$1world\$1stack.py** und fügen Sie den folgenden Code in die Datei ein. Dies enthält den [Lambda-Konstruktor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), der die Lambda-Funktion erstellt, Umgebungsvariablen für Powertools konfiguriert und die Protokollspeicherung auf eine Woche festlegt, und den [ ApiGatewayv1-Konstruktor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), der die REST-API erstellt.
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# Using AWS Lambda Powertools via Lambda Layer
# This imports the Powertools layer which provides observability features for Lambda functions
# For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_9,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Stellen Sie die Anwendung bereit.
```
cd ..
cdk deploy
```
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl GET
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html) aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter [Arbeiten mit Protokollen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) im *AWS Serverless Application Model -Entwicklerhandbuch*.
```
sam logs --stack-name HelloWorldStack
```
Das Ergebnis sieht folgendermaßen aus:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```
# AWS Lambda-Funktionstests in Python
**Anmerkung**
Im Kapitel [Testen von Funktionen](testing-guide.md) finden Sie eine vollständige Einführung in Techniken und bewährte Methoden für das Testen von Serverless-Lösungen.
Beim Testen der Serverless-Funktionen werden herkömmliche Testtypen und -techniken verwendet. Erwägen Sie jedoch auch das Testen der Serverless-Anwendungen als Ganzes. Cloud-basierte Tests bieten das **genaueste** Maß für die Qualität sowohl Ihrer Funktionen als auch Ihrer Serverless-Anwendungen.
Eine Serverless-Anwendungsarchitektur umfasst verwaltete Services, die über API-Aufrufe wichtige Anwendungsfunktionen bereitstellen. Aus diesem Grund muss Ihr Entwicklungszyklus automatisierte Tests beinhalten, die bei der Interaktion Ihrer Funktionen und Services die Funktionalität überprüfen.
Wenn Sie keine cloud-basierten Tests erstellen, können aufgrund von Unterschieden zwischen Ihrer lokalen Umgebung und der bereitgestellten Umgebung Probleme auftreten. Ihr kontinuierlicher Integrationsprozess muss Tests anhand einer Reihe von Ressourcen durchführen, die in der Cloud bereitgestellt werden, bevor Ihr Code in die nächste Bereitstellungsumgebung wie QA, Staging oder Produktion übertragen wird.
Lesen Sie diesen kurzen Leitfaden weiter, um weitere Informationen zu Teststrategien für Serverless-Anwendungen zu erhalten, oder besuchen Sie das [Serverless Test Samples Repository](https://github.com/aws-samples/serverless-test-samples), um praktische Beispiele zu finden, die sich speziell auf die gewählte Sprache und Laufzeit beziehen.
![\[illustration showing the relationship between types of tests\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-type-illustration2.png)
Für Serverless-Tests schreiben Sie weiterhin *Einheiten*-, *Integrations*- und *End-to-End*-Tests.
+ **Einheitentests** — Tests, die an einem isolierten Codeblock ausgeführt werden. Zum Beispiel die Überprüfung der Geschäftslogik zur Berechnung der Bereitstellungskosten für einen bestimmten Artikel und Bestimmungsort.
+ **Integrationstests** — Tests, an denen zwei oder mehr Komponenten oder Dienste beteiligt sind, die interagieren, in der Regel in einer Cloud-Umgebung. Bei der Überprüfung einer Funktion werden beispielsweise Ereignisse aus einer Warteschlange verarbeitet.
+ **End-to-End-Tests** — Tests, die das Verhalten einer gesamten Anwendung überprüfen. Stellen Sie beispielsweise sicher, dass die Infrastruktur korrekt eingerichtet ist und die Ereignisse zwischen den Services wie erwartet ablaufen, um die Bestellungen der Kunden aufzuzeichnen.
## Testen Ihrer Serverless-Anwendungen
In der Regel verwenden Sie eine Mischung aus verschiedenen Ansätzen, um Ihren Serverless-Anwendungscode zu testen, einschließlich Tests in der Cloud, Tests mit Mock-Code und gelegentlich Tests mit Emulatoren.
### Testen in der Cloud
Das Testen in der Cloud ist für alle Testphasen von Nutzen, einschließlich Einheitentests, Integrationstests und End-to-End-Tests. Sie führen Tests für Code durch, der in der Cloud bereitgestellt wird und mit cloud-basierten Services interagiert. Dieser Ansatz bietet das **genaueste** Maß für die Qualität Ihres Codes.
Eine bequeme Möglichkeit, Ihre Lambda-Funktion in der Cloud zu debuggen, ist die Verwendung der Konsole mit einem Testereignis. Ein *Testereignis* ist eine JSON-Eingabe für Ihre Funktion. Wenn Ihre Funktion keine Eingabe erfordert, kann das Ereignis ein leeres JSON-Dokument `({})` sein. Die Konsole bietet Beispielereignisse für eine Vielzahl von Service-Integrationen. Nachdem Sie ein Ereignis in der Konsole erstellt haben, können Sie es mit Ihrem Team teilen, um das Testen einfacher und einheitlicher zu gestalten.
**Anmerkung**
Das [Testen einer Funktion in der Konsole](testing-functions.md) ist ein schneller Einstieg, aber die Automatisierung Ihrer Testzyklen gewährleistet die Anwendungsqualität und die Entwicklungsgeschwindigkeit.
### Test-Tools
Es gibt Tools und Techniken, um die Feedback-Schleifen bei der Entwicklung zu beschleunigen. [AWSSAM Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/accelerate.html) und [AWSCDK Watch Mode](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch) reduzieren beispielsweise beide die Zeit, die für die Aktualisierung von Cloud-Umgebungen benötigt wird.
[Moto](https://pypi.org/project/moto/) ist eine Python-Bibliothek für das Mocking von AWS-Services und -Ressourcen, sodass Sie Ihre Funktionen mit wenigen oder gar keinen Änderungen testen können, indem Sie Dekoratoren zum Abfangen und Simulieren von Antworten verwenden.
Das Validierungsfeature von [Powertools für AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python/latest/utilities/validation/) bietet Dekoratoren, mit denen Sie Eingabeereignisse und Ausgabeantworten Ihrer Python-Funktionen validieren können.
Weitere Informationen finden Sie im Blogbeitrag [Unit Testing Lambda with Python and Mock AWS Services](https://aws.amazon.com/blogs/devops/unit-testing-aws-lambda-with-python-and-mock-aws-services/).
Informationen zur Verringerung der Latenzzeit bei Iterationen der Cloud-Bereitstellung finden Sie unter [AWS Serverless Application Model (AWS SAM) Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-sync.html), [AWS Cloud Development Kit (Watch-Modus AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch). Diese Tools überwachen Ihre Infrastruktur und Ihren Code auf Änderungen. Sie reagieren auf diese Änderungen, indem sie automatisch inkrementelle Updates erstellen und in Ihrer Cloud-Umgebung bereitstellen.
Beispiele, in denen diese Tools verwendet werden, sind im Code-Repository mit [Python-Testbeispielen](https://github.com/aws-samples/serverless-test-samples/tree/main/python-test-samples) verfügbar.
# Instrumentierung von Python-Code in AWS Lambda
Lambda lässt sich integrieren AWS X-Ray , um Ihnen zu helfen, Lambda-Anwendungen zu verfolgen, zu debuggen und zu optimieren. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, die Lambda-Funktionen und andere AWS -Services enthalten können.
Um Protokollierungsdaten an X-Ray zu senden, können Sie eine von drei SDK-Bibliotheken verwenden:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Eine sichere, produktionsbereite und AWS unterstützte Distribution des () SDK. OpenTelemetry OTel
+ [AWS X-Ray-SDK für Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) – Ein SDK zum Generieren und Senden von Nachverfolgungsdaten an X-Ray.
+ [Powertools for AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/latest/) — Ein Entwickler-Toolkit zur Implementierung serverloser Best Practices und zur Steigerung der Entwicklergeschwindigkeit.
Jedes SDKs bietet Möglichkeiten, Ihre Telemetriedaten an den X-Ray-Dienst zu senden. Sie können dann mit X-Ray die Leistungsmetriken Ihrer Anwendung anzeigen, filtern und erhalten, um Probleme und Möglichkeiten zur Optimierung zu identifizieren.
**Wichtig**
X-Ray und Powertools für AWS Lambda SDKs sind Teil einer eng integrierten Instrumentierungslösung, die von AWS angeboten wird. Die ADOT Lambda Layers sind Teil eines branchenweiten Standards für die Verfolgung von Instrumenten, die im Allgemeinen mehr Daten erfassen, aber möglicherweise nicht für alle Anwendungsfälle geeignet sind. Sie können die end-to-end Ablaufverfolgung in X-Ray mit beiden Lösungen implementieren. Weitere Informationen zur Auswahl zwischen beiden finden Sie unter [Wählen zwischen der AWS Distribution für Open Telemetry und](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs
**Topics**
+ [Powertools für AWS Lambda (Python) und AWS SAM für das Tracing verwenden](#python-tracing-sam)
+ [Verwenden von Powertools für AWS Lambda (Python) und AWS CDK für das Tracing](#python-logging-cdk)
+ [Verwenden von ADOT zum Instrumentieren Ihrer Python-Funktionen](#python-adot)
+ [Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Python-Funktionen](#python-xray-sdk)
+ [Aktivieren der Nachverfolgung mit der Lambda-Konsole](#python-tracing-console)
+ [Aktivieren der Nachverfolgung mit der Lambda-API](#python-tracing-api)
+ [Die Ablaufverfolgung wird aktiviert mit CloudFormation](#python-tracing-cloudformation)
+ [Interpretieren einer X-Ray-Nachverfolgung](#python-tracing-interpretation)
+ [Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)](#python-tracing-layers)
## Powertools für AWS Lambda (Python) und AWS SAM für das Tracing verwenden
Gehen Sie wie folgt vor, um eine Hello World Python-Beispielanwendung mit integrierten [Powertools for AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu die AWS SAM. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine Hello-World-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Python 3.11
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS SAM Beispielanwendung bereit**
1. Initialisieren Sie die Anwendung mit der Hello World Python-Vorlage.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.11 --no-tracing
```
1. Entwickeln Sie die App.
```
cd sam-app && sam build
```
1. Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
**Anmerkung**
Für ist **HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung?** , stellen Sie sicher, dass Sie eintreten`y`.
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl -X GET
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.
## Verwenden von Powertools für AWS Lambda (Python) und AWS CDK für das Tracing
Gehen Sie wie folgt vor, um eine Hello World Python-Beispielanwendung mit integrierten [Powertools for AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu die AWS CDK. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine Hello-World-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Python 3.11
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS CDK Beispielanwendung bereit**
1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
1. Initialisieren Sie die App.
```
cdk init app --language python
```
1. Installieren Sie die Python-Abhängigkeiten.
```
pip install -r requirements.txt
```
1. Erstellen Sie ein Verzeichnis **lambda\$1function** unter dem Stammordner.
```
mkdir lambda_function
cd lambda_function
```
1. Erstellen Sie eine Datei namens **app.py** und fügen Sie den folgenden Code zur Datei hinzu. Dies ist der Code für die Lambda-Funktion.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Öffnen Sie das Verzeichnis **hello\$1world**. Sie sollten eine Datei mit dem Namen **hello\$1world\$1stack.py** sehen.
```
cd ..
cd hello_world
```
1. Öffnen Sie **hello\$1world\$1stack.py** und fügen Sie den folgenden Code in die Datei ein. Dies enthält den [Lambda-Konstruktor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), der die Lambda-Funktion erstellt, Umgebungsvariablen für Powertools konfiguriert und die Protokollspeicherung auf eine Woche festlegt, und den [ ApiGatewayv1-Konstruktor](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), der die REST-API erstellt.
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
# See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
# Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_11,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Stellen Sie die Anwendung bereit.
```
cd ..
cdk deploy
```
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl -X GET
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```
## Verwenden von ADOT zum Instrumentieren Ihrer Python-Funktionen
ADOT bietet vollständig verwaltete [Lambda-Schichten](chapter-layers.md), die alles zusammenfassen, was Sie für die Erfassung von Telemetriedaten mithilfe des SDK benötigen. OTel Indem Sie diese Ebene verwenden, können Sie Ihre Lambda-Funktionen instrumentieren, ohne einen Funktionscode ändern zu müssen. Sie können Ihren Layer auch so konfigurieren, dass er eine benutzerdefinierte Initialisierung von durchführt. OTel Weitere Informationen finden Sie unter [Benutzerdefinierte Konfiguration für den ADOT Collector auf Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) in der ADOT-Dokumentation.
Für Python-Laufzeiten können Sie den **AWS -verwaltete Lambda-Layer für ADOT Python** hinzufügen, um Ihre Funktionen automatisch zu instrumentieren. Dieser Layer funktioniert sowohl für arm64- als auch für x86\$164-Architekturen. Eine ausführliche Anleitung zum Hinzufügen dieser Ebene finden Sie unter [AWS Distro for OpenTelemetry Lambda Support for Python](https://aws-otel.github.io/docs/getting-started/lambda/lambda-python) in der ADOT-Dokumentation.
## Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Python-Funktionen
Um Details zu Aufrufen aufzuzeichnen, die Ihre Lambda-Funktion an andere Ressourcen in Ihrer Anwendung vornimmt, können Sie auch AWS X-Ray-SDK für Python verwenden. Um das SDK zu erhalten, fügen Sie das `aws-xray-sdk`-Paket den Abhängigkeiten Ihrer Anwendung hinzu.
**Example [requirements.txt](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/requirements.txt)**
```
jsonpickle==1.3
aws-xray-sdk==2.4.3
```
In Ihrem Funktionscode können Sie AWS SDK-Clients instrumentieren, indem Sie die `boto3` Bibliothek mit dem Modul patchen. `aws_xray_sdk.core`
**Example [Funktion — Einen SDK-Client AWS verfolgen](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/lambda_function.py)**
```
import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()
client = boto3.client('lambda')
client.get_account_settings()
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
...
```
Aktivieren Sie nach Hinzufügen der richtigen Abhängigkeiten die Nachverfolgung in der Konfiguration Ihrer Funktion über die Lambda-Konsole oder die API.
## Aktivieren der Nachverfolgung mit der Lambda-Konsole
Gehen Sie folgendermaßen vor, um die aktive Nachverfolgung Ihrer Lambda-Funktion mit der Konsole umzuschalten:
**So aktivieren Sie die aktive Nachverfolgung**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie eine Funktion aus.
1. Wählen Sie **Configuration** (Konfiguration) und dann **Monitoring and operations tools** (Überwachungs- und Produktionstools).
1. Wählen Sie unter **Zusätzliche Überwachungstools** die Option **Bearbeiten** aus.
1. Wählen Sie unter **CloudWatch Anwendungssignale und AWS X-Ray** die Option **Enable** for **Lambda Service Traces** aus.
1. Wählen Sie **Speichern**.
## Aktivieren der Nachverfolgung mit der Lambda-API
Konfigurieren Sie die Ablaufverfolgung für Ihre Lambda-Funktion mit dem AWS CLI oder AWS SDK und verwenden Sie die folgenden API-Operationen:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
**Der folgende AWS CLI Beispielbefehl aktiviert die aktive Ablaufverfolgung für eine Funktion namens my-function.**
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Der Ablaufverfolgungsmodus ist Teil der versionsspezifischen Konfiguration, wenn Sie eine Version Ihrer Funktion veröffentlichen. Sie können den Ablaufverfolgungsmodus für eine veröffentlichte Version nicht ändern.
## Die Ablaufverfolgung wird aktiviert mit CloudFormation
Um die Ablaufverfolgung für eine `AWS::Lambda::Function` Ressource in einer CloudFormation Vorlage zu aktivieren, verwenden Sie die `TracingConfig` Eigenschaft.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Verwenden Sie für eine `AWS::Serverless::Function` Ressource AWS Serverless Application Model (AWS SAM) die `Tracing` Eigenschaft.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretieren einer X-Ray-Nachverfolgung
Ihre Funktion benötigt die Berechtigung zum Hochladen von Trace-Daten zu X-Ray. Wenn Sie die aktive Nachverfolgung in der Lambda-Konsole aktivieren, fügt Lambda der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion die erforderlichen Berechtigungen hinzu. Andernfalls fügen Sie die [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)Richtlinie der Ausführungsrolle hinzu.
Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Das [X-Ray-Service-Diagramm](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) zeigt Informationen über Ihre Anwendung und alle ihre Komponenten an. Das folgende Beispiel zeigt eine Anwendung mit zwei Funktionen. Die primäre Funktion verarbeitet Ereignisse und gibt manchmal Fehler zurück. Die zweite Funktion an oberster Stelle verarbeitet Fehler, die in der Protokollgruppe der ersten auftreten, und verwendet das AWS SDK, um X-Ray, Amazon Simple Storage Service (Amazon S3) und Amazon CloudWatch Logs aufzurufen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.
In X-Ray, zeichnet eine *Ablaufverfolgung* Informationen zu einer Anforderung auf, die von einem oder mehreren *Services* verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/xray-servicemap-function.png)
Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen **my-function**, aber einer hat einen Ursprung von `AWS::Lambda` und der andere hat einen Ursprung von `AWS::Lambda::Function`. Wenn das `AWS::Lambda`-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das `AWS::Lambda::Function`-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Dieses Beispiel erweitert das `AWS::Lambda::Function`-Segment, um seine drei Untersegmente anzuzeigen.
**Anmerkung**
AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.
Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.
Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.
Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:
+ **Initialisierung** – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des [Initialisierungscodes](foundation-progmodel.md) aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
+ **Invocation** (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
+ **Overhead** (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.
Das Funktionssegment im neuen Stil enthält kein `Invocation`-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter [Grundlegendes zu X-Ray-Ablaufverfolgungen](services-xray.md#services-xray-traces).
Sie können auch HTTP-Clients instrumentieren, SQL-Abfragen aufzeichnen und benutzerdefinierte Untersegmente mit Anmerkungen und Metadaten erstellen. Weitere Informationen finden Sie unter [AWS X-Ray-SDK für Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) im *AWS X-Ray -Entwicklerhandbuch*.
**Preisgestaltung**
Im Rahmen des kostenlosen Kontingents können Sie X-Ray Tracing jeden Monat bis zu einem bestimmten Limit AWS kostenlos nutzen. Über den Schwellenwert hinaus berechnet X-Ray Gebühren für die Speicherung und den Abruf der Nachverfolgung. Weitere Informationen finden Sie unter [AWS X-Ray Preise](https://aws.amazon.com/xray/pricing/).
## Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)
Wenn Sie das X-Ray-SDK verwenden, um AWS SDK-Clients Ihren Funktionscode zu instrumentieren, kann Ihr Bereitstellungspaket ziemlich umfangreich werden. Um Laufzeitabhängigkeiten bei jeder Aktualisierung des Funktionscodes zu vermeiden, verpacken Sie das X-Ray-SDK in einer [Lambda-Ebene](chapter-layers.md).
Das folgende Beispiel zeigt eine `AWS::Serverless::LayerVersion`-Ressource, die das AWS X-Ray-SDK für Python speichert.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/template.yml) – Abhängigkeitenebene**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-python-lib
Description: Dependencies for the blank-python sample app.
ContentUri: package/.
CompatibleRuntimes:
- python3.11
```
Bei dieser Konfiguration aktualisieren Sie die Bibliotheksebene nur, wenn Sie Ihre Laufzeitabhängigkeiten ändern. Da das Funktionsbereitstellungspaket nur Ihren Code enthält, kann dies dazu beitragen, die Upload-Zeiten zu reduzieren.
Das Erstellen einer Ebene für Abhängigkeiten erfordert Build-Konfigurationsänderungen, um das Ebenen-Archiv vor der Bereitstellung zu generieren. Ein funktionierendes Beispiel finden Sie in der Beispielanwendung [blank-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python) .