Verpacken Ihres Ebeneninhalts Ebene in Lambda erstellen Ebene zu Ihrer Funktion hinzufügen Beispiel-App

Arbeiten mit Ebenen für Node.js Lambda-Funktionen

Verwenden Sie Lambda-Ebenen, 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 oder Konfigurationsdateien. Das Erstellen einer Ebene umfasst drei allgemeine Schritte:

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.
Erstellen Sie die Ebene in Lambda.
Fügen Sie die Ebene zu Ihren Funktionen hinzu.

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 Node.js, die Sie für die Lambda-Funktion verwenden möchten. Wenn Sie Ihre Ebene beispielsweise mit Node.js 22 erstellen, verwenden Sie die Laufzeit Node.js 22 für Ihre Funktion.
Die ZIP-Datei Ihrer Ebene muss eine der folgenden Verzeichnisstrukturen verwenden:
- nodejs/node_modules
- nodejs/nodeX/node_modules (wobei X Ihre Version von Node.js ist, z. B. node22)
Weitere Informationen finden Sie unter Ebenenpfade für jede Lambda-Laufzeit.
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 npm installierte Node.js-Bibliotheken von Drittanbietern (wie axios oder lodash) oder Ihre eigenen JavaScript-Module enthalten.

So erstellen Sie eine Ebene mit npm-Paketen

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 oder bcrypt) sicher, dass sie mit der Lambda-Linux-Umgebung und der Architektur 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.
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.

So erstellen Sie eine Ebene mithilfe Ihres eigenen Codes

Erstellen Sie die erforderliche Verzeichnisstruktur für Ihre Ebene:


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

Erstellen Sie eine package.json-Datei für Ihr benutzerdefiniertes Modul, um zu definieren, wie es importiert werden soll:
Beispiel nodejs/node_modules/validator/package.json
```
{
  "name": "validator",
  "version": "1.0.0",
  "type": "module",
  "main": "index.mjs"
}
```

Erstellen Sie Ihre JavaScript-Moduldatei:

Beispiel nodejs/node_modules/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)
  };
}

Verpacken Sie den Ebeneninhalt:

Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:

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

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 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\"}}"
}

Ebene in Lambda erstellen

Sie können Ihre Ebene entweder über die AWS CLI oder die Lambda-Konsole veröffentlichen.

Ebene zu Ihrer Funktion hinzufügen

Beispiel-App

Weitere Beispiele für die Verwendung von Lambda-Ebenen finden Sie in der Beispielanwendung layer-nodejs im GitHub-Repository des AWS Lambda-Entwicklerhandbuchs. Diese Anwendung enthält eine Ebene, die die 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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Bereitstellen von Container-Images

Kontext

Arbeiten mit Ebenen für Node.js Lambda-Funktionen

Themen

Verpacken Ihres Ebeneninhalts

So erstellen Sie eine Ebene mit npm-Paketen

Anmerkung

Anmerkung

So erstellen Sie eine Ebene mithilfe Ihres eigenen Codes

Beispiel nodejs/node_modules/validator/package.json

Beispiel nodejs/node_modules/validator/index.mjs

Ebene in Lambda erstellen

So erstellen Sie eine Ebene (Konsole)

Ebene zu Ihrer Funktion hinzufügen

So fügen Sie eine Ebene zu einer Funktion hinzu

Anmerkung

Beispiel-App