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.

# Arbeiten mit Ebenen für Python Lambda-Funktionen
<a name="python-layers"></a>

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
<a name="python-layers-package"></a>

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
<a name="python-layers-third-party-dependencies"></a>

**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
<a name="custom-python-modules"></a>

**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
<a name="publishing-layer"></a>

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
<a name="python-layer-adding"></a>

------
#### [ 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
<a name="python-layer-sample-app"></a>

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.