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 Node.js Lambda-Funktionen
<a name="nodejs-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
](#nodejs-layers-package)
+ [

## Erstellen Sie die Ebene in Lambda
](#publishing-layer)
+ [

## Fügen Sie die Ebene zu Ihrer Funktion hinzu
](#nodejs-layer-adding)
+ [

## Beispiel-App
](#nodejs-layer-sample-app)

## Verpacken Ihres Ebeneninhalts
<a name="nodejs-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 Node.js, die Sie für die Lambda-Funktion verwenden möchten. Wenn Sie Ihren Layer beispielsweise mit Node.js 24 erstellen, verwenden Sie die Laufzeit Node.js 24 für Ihre Funktion.
+ Die ZIP-Datei Ihrer Ebene muss eine der folgenden Verzeichnisstrukturen verwenden:
  + `nodejs/node_modules`
  + `nodejs/nodeX/node_modules`(wo *X* ist zum Beispiel Ihre Node.js -Version`node22`)

  Weitere Informationen finden Sie unter [Ebenenpfade für jede Lambda-Laufzeit](packaging-layers.md#packaging-layers-paths).
+ 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 Bibliotheken vom Typ Node.js von Drittanbietern enthalten, die mit installiert wurden `npm` (z. B. `axios` oder`lodash`), oder Ihre eigenen JavaScript Module.

### Abhängigkeiten von Drittanbietern
<a name="nodejs-layers-third-party-dependencies"></a>

**So erstellen Sie eine Ebene mit npm-Paketen**

1. Erstellen Sie die erforderliche Verzeichnisstruktur und installieren Sie Pakete direkt darin:

   ```
   mkdir -p nodejs
   npm install --prefix nodejs lodash axios
   ```

   Mit diesem Befehl werden die Pakete direkt in das Verzeichnis `nodejs/node_modules` installiert. Dies ist die Struktur, die Lambda benötigt.
**Anmerkung**  
Stellen Sie bei Paketen mit nativen Abhängigkeiten oder binären Komponenten (wie [sharp](https://www.npmjs.com/package/sharp) oder [bcrypt](https://www.npmjs.com/package/bcrypt)) sicher, dass sie mit der Lambda-Linux-Umgebung und der [Architektur](foundation-arch.md) Ihrer Funktion kompatibel sind. Möglicherweise müssen Sie das Flag `--platform` verwenden:  

   ```
   npm install --prefix nodejs --platform=linux --arch=x64 sharp
   ```
Bei komplexeren nativen Abhängigkeiten ist es unter Umständen erforderlich, diese in einer Linux-Umgebung zu kompilieren, die der Lambda-Laufzeit entspricht. Zu diesem Zweck können Sie Docker verwenden.

1. Verpacken Sie den Ebeneninhalt:

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

   Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:

   ```
   nodejs/
   ├── package.json
   ├── package-lock.json
   └── node_modules/
       ├── lodash/
       ├── axios/
       └── (dependencies of the other packages)
   ```
**Anmerkung**  
Stellen Sie sicher, dass Ihre ZIP-Datei das `nodejs`-Verzeichnis auf der Stammebene enthält und sich `node_modules` darin befindet. Diese Struktur stellt sicher, dass Lambda Ihre Pakete finden und importieren kann.
Die Dateien `package.json` und `package-lock.json` im `nodejs/`-Verzeichnis werden von npm für die Abhängigkeitsverwaltung verwendet, sind aber für die Funktionalität der Ebenen von Lambda nicht erforderlich. Jedes installierte Paket enthält bereits eine eigene `package.json`-Datei, die definiert, wie Lambda das Paket importiert.

### Benutzerdefinierte JavaScript Module
<a name="custom-nodejs-modules"></a>

**So erstellen Sie eine Ebene mithilfe Ihres eigenen Codes**

1. Erstellen Sie die erforderliche Verzeichnisstruktur für Ihre Ebene:

   ```
   mkdir -p nodejs/node_modules/validator
   cd nodejs/node_modules/validator
   ```

1. Erstellen Sie eine `package.json`-Datei für Ihr benutzerdefiniertes Modul, um zu definieren, wie es importiert werden soll:  
**Example nodejs/node\$1modules/validator/package.json**  

   ```
   {
     "name": "validator",
     "version": "1.0.0",
     "type": "module",
     "main": "index.mjs"
   }
   ```

1. Erstellen Sie Ihre JavaScript Moduldatei:  
**Example nodejs/node\$1modules/validator/index.mjs**  

   ```
   export function validateOrder(orderData) {
     // Validates an order and returns formatted data
     const requiredFields = ['productId', 'quantity'];
     
     // Check required fields
     const missingFields = requiredFields.filter(field => !(field in orderData));
     if (missingFields.length > 0) {
       throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
     }
     
     // Validate quantity
     const quantity = orderData.quantity;
     if (!Number.isInteger(quantity) || quantity < 1) {
       throw new Error('Quantity must be a positive integer');
     }
     
     // Format and return the validated data
     return {
       productId: String(orderData.productId),
       quantity: quantity,
       shippingPriority: orderData.priority || 'standard'
     };
   }
   
   export function formatResponse(statusCode, body) {
     // Formats the API response
     return {
       statusCode: statusCode,
       body: JSON.stringify(body)
     };
   }
   ```

1. Verpacken Sie den Ebeneninhalt:

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

   Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:

   ```
   nodejs/              
   └── node_modules/
       └── validator/
           ├── package.json
           └── index.mjs
   ```

1. Importieren und verwenden Sie die Module in Ihrer Funktion. Beispiel:

   ```
   import { validateOrder, formatResponse } from 'validator';
   
   export const handler = async (event) => {
     try {
       // Parse the order data from the event body
       const orderData = JSON.parse(event.body || '{}');
       
       // Validate and format the order
       const validatedOrder = validateOrder(orderData);
       
       return formatResponse(200, {
         message: 'Order validated successfully',
         order: validatedOrder
       });
     } catch (error) {
       if (error instanceof Error && error.message.includes('Missing required fields')) {
         return formatResponse(400, {
           error: error.message
         });
       }
       
       return formatResponse(500, {
         error: 'Internal server error'
       });
     }
   };
   ```

   Sie können das folgende [Testereignis](testing-functions.md#invoke-with-event) verwenden, um die Funktion aufzurufen:

   ```
   {
       "body": "{\"productId\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
   }
   ```

   Erwartete Antwort:

   ```
   {
     "statusCode": 200,
     "body": "{\"message\":\"Order validated successfully\",\"order\":{\"productId\":\"ABC123\",\"quantity\":2,\"shippingPriority\":\"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 nodejs24.x
```

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 Node.js-Laufzeit aus, die der Node.js-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="nodejs-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="nodejs-layer-sample-app"></a>

Weitere Beispiele für die Verwendung von Lambda-Layern finden Sie in der [Layer-Nodejs-Beispielanwendung](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) im Developer Guide-Repository. AWS Lambda GitHub Diese Anwendung enthält eine Ebene, die die [lodash](https://www.npmjs.com/package/lodash)-Bibliothek enthält. Nach dem Erstellen der Ebene können Sie die entsprechende Funktion bereitstellen und aufrufen, um zu bestätigen, dass die Ebene wie erwartet funktioniert.