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 Node.js
Sie können JavaScript Code mit Node.js in AWS Lambda ausführen. Lambda bietet [Laufzeiten](lambda-runtimes.md) für Node.js, die Ihren Code ausführen, um Ereignisse zu verarbeiten. Ihr Code wird in einer Umgebung ausgeführt, die die Rolle AWS SDK für JavaScript, with credentials from a AWS Identity and Access Management (IAM) enthält, die Sie verwalten. Weitere Informationen zu den SDK-Versionen, die in den Laufzeiten von Node.js enthalten sind, finden Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](#nodejs-sdk-included).
Lambda unterstützt die folgenden Node.js-Laufzeiten.
| Name | ID | Betriebssystem | Datum der Veraltung | Blockfunktion erstellen | Blockfunktion aktualisieren |
| --- | --- | --- | --- | --- | --- |
| Node.js 24 | `nodejs24.x` | Amazon Linux 2023 | 30. April 2028 | 1. Juni 2028 | 1. Juli 2028 |
| Node.js 22 | `nodejs22.x` | Amazon Linux 2023 | 30. April 2027 | 1. Juni 2027 | 1. Juli 2027 |
| Node.js 20 | `nodejs20.x` | Amazon Linux 2023 | 30. April 2026 | 31. August 2026 | 30. September 2026 |
**Erstellen einer Funktion Node.js.**
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ählen Sie **Node.js 24.x**.
1. Wählen Sie **Funktion erstellen**.
Die Konsole erstellt eine Lambda-Funktion mit einer einzigen Quelldatei mit dem Namen `index.mjs`. 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.
Die `index.mjs`-Datei exportiert eine Funktion mit dem Namen `handler`, die ein Ereignisobjekt und ein Kontext-Objekt übernimmt. Dies ist die [Handler-Funktion](nodejs-handler.md), die bei einem Aufruf der Funktion von Lambda aufgerufen wird. Die Node.js-Funktionslaufzeit ruft Aufrufereignisse von Lambda ab und leitet sie an den Handler weiter. In der Konfiguration der Funktion lautet der Wert für den Handler `index.handler`.
Wenn Sie Ihren Funktionscode speichern, erstellt die Lambda-Konsole ein Bereitstellungspaket für das ZIP-Dateiarchiv. Wenn Sie Ihren Funktionscode außerhalb der Konsole (mit einer IDE) entwickeln, müssen Sie [ein Bereitstellungspaket erstellen](nodejs-package.md), um Ihren Code in die Lambda-Funktion hochzuladen.
Die Funktionslaufzeit übergibt neben dem Aufrufereignis ein Context-Objekt an den Handler. Das [Context-Objekt](nodejs-context.md) enthält zusätzliche Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung. Weitere Informationen erhalten Sie über die Umgebungsvariablen.
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](nodejs-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
](#nodejs-sdk-included)
+ [
## Verwenden von Keepalive für TCP-Verbindungen
](#nodejs-keep-alive)
+ [
## CA-Zertifikat wird geladen
](#nodejs-certificate-loading)
+ [
## Experimentelle Funktionen von Node.js
](#nodejs-experimental-features)
+ [
# Lambda-Funktionshandler in Node.js definieren
](nodejs-handler.md)
+ [
# Bereitstellen von Node.js Lambda-Funktionen mit ZIP-Dateiarchiven
](nodejs-package.md)
+ [
# Bereitstellen von Node.js-Lambda-Funktionen mit Container-Images
](nodejs-image.md)
+ [
# Arbeiten mit Ebenen für Node.js Lambda-Funktionen
](nodejs-layers.md)
+ [
# Verwenden des Lambda-Kontextobjekts zum Abrufen von Node.js-Funktionsinformationen
](nodejs-context.md)
+ [
# Node.js-Lambda-Funktionen protokollieren und überwachen
](nodejs-logging.md)
+ [
# Instrumentierung von Node.js Code in AWS Lambda
](nodejs-tracing.md)
## SDK-Versionen, die zur Laufzeit enthalten sind
Alle [unterstützten Lambda Node.js Runtimes](#nodejs-supported-runtimes) enthalten eine bestimmte Nebenversion der Version AWS SDK für JavaScript 3, nicht die [neueste](https://github.com/aws/aws-sdk-js-v3/releases) Version. Welche Nebenversion in der Laufzeit enthalten ist, hängt von der Laufzeitversion und Ihrer AWS-Region ab. Um die spezifische Version des SDK zu finden, die in der von Ihnen verwendeten Laufzeit enthalten ist, erstellen Sie eine Lambda-Funktion mit dem folgenden Code.
**Example index.mjs**
```
import packageJson from '@aws-sdk/client-s3/package.json' with { type: 'json' };
export const handler = async () => ({ version: packageJson.version });
```
Dies gibt eine Antwort im folgenden Format zurück:
```
{
"version": "3.632.0"
}
```
Weitere Informationen finden Sie unter [Verwenden Sie das SDK für JavaScript v3 in Ihrem Handler](nodejs-handler.md#nodejs-example-sdk-usage).
## Verwenden von Keepalive für TCP-Verbindungen
Der HTTP/HTTPS Standardagent Node.js erstellt für jede neue Anfrage eine neue TCP-Verbindung. Um die Kosten für den Aufbau neuer Verbindungen zu vermeiden, ist Keep-alive in allen [unterstützten Node.js-Laufzeiten](#nodejs-supported-runtimes) standardmäßig aktiviert. Keepalive kann die Anforderungszeiten für Lambda-Funktionen reduzieren, die mehrere API-Aufrufe unter Verwendung des SDK ausführen.
Informationen zum Deaktivieren von Keep-Alive finden Sie unter [Wiederverwenden von Verbindungen mit Keep-Alive in Node.js im AWS](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html) *SDK for* 3.x Developer Guide. JavaScript Weitere Informationen zur Verwendung von Keep-Alive finden Sie im Developer Tools Blog unter [HTTP keep-alive is default on in modular](https://aws.amazon.com/blogs/developer/http-keep-alive-is-on-by-default-in-modular-aws-sdk-for-javascript/) SDK. AWS JavaScript AWS
## CA-Zertifikat wird geladen
Für Node.js-Laufzeitversionen bis Node.js 18 lädt Lambda automatisch Amazon-spezifische CA-Zertifikate (Certificate Authority, Zertifizierungsstelle), um Ihnen die Erstellung von Funktionen zu erleichtern, die mit anderen AWS-Services interagieren. Lambda enthält beispielsweise die Amazon-RDS-Zertifikate, die für die Validierung des in Ihrer Amazon-RDS-Datenbank installierten [Server-Identitätszertifikats](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html) erforderlich sind. Dieses Verhalten kann sich bei Kaltstarts auf die Leistung auswirken.
Ab Node.js 20 lädt Lambda standardmäßig keine zusätzlichen CA-Zertifikate mehr. Die Laufzeit Node.js 20 enthält eine Zertifikatsdatei mit allen Amazon-CA-Zertifikaten, die sich unter `/var/runtime/ca-cert.pem` befinden. Um dasselbe Verhalten aus Node.js 18 und früheren Laufzeiten wiederherzustellen, setzen Sie die [Umgebungsvariable](configuration-envvars.md) `NODE_EXTRA_CA_CERTS` auf `/var/runtime/ca-cert.pem`.
Für eine optimale Leistung empfehlen wir, nur die benötigten Zertifikate mit Ihrem Bereitstellungspaket zu bündeln und diese über die Umgebungsvariable `NODE_EXTRA_CA_CERTS` zu laden. Die Zertifikatsdatei sollte aus einem oder mehreren vertrauenswürdigen Stammzertifikaten oder Zertifikaten von Zwischenzertifizierungsstellen im PEM-Format bestehen. Fügen Sie für RDS die erforderlichen Zertifikate beispielsweise zusammen mit Ihrem Code als `certificates/rds.pem` hinzu. Laden Sie dann die Zertifikate, indem Sie `NODE_EXTRA_CA_CERTS` auf `/var/task/certificates/rds.pem` festlegen.
## Experimentelle Funktionen von Node.js
Die Upstream-Sprachversionen von Node.js ermöglichen standardmäßig einige experimentelle Features. Lambda deaktiviert diese Features, um die Laufzeitstabilität und eine konsistente Leistung zu gewährleisten. In der folgenden Tabelle sind die experimentellen Features aufgeführt, die Lambda deaktiviert.
| Experimentelle Features | Unterstützte Node.js-Versionen | Von Lambda angewendetes Node.js-Flag | Lambda-Flag zum erneuten Aktivieren |
| --- | --- | --- | --- |
| Support für den Import von Modulen mithilfe von „require“ in ES-Modulen | Node.js 20, Node.js 22 | `--no-experimental-require-module` | `--experimental-require-module` |
| Support für die automatische Erkennung von ES- und CommonJS-Modulen | Node.js 22 | `--no-experimental-detect-module` | `--experimental-detect-module` |
Um ein deaktiviertes experimentelles Feature zu aktivieren, setzen Sie das Reaktivierungs-Flag in der Umgebungsvariablen „`NODE_OPTIONS`“. Beispiel: Um die Unterstützung für „require“ in ES-Modulen zu aktivieren, setzen Sie „`NODE_OPTIONS`“ auf „`--experimental-require-module`“. Lambda erkennt diese Überschreibung und entfernt das entsprechende Deaktivierungs-Flag.
**Wichtig**
Die Verwendung experimenteller Features kann zu Instabilität und Leistungsproblemen führen. Diese Features könnten in zukünftigen Versionen von Node.js geändert oder entfernt werden. Funktionen, die experimentelle Features nutzen, sind nicht für das Lambda Service Level Agreement (SLA) oder AWS Support qualifiziert.
# Lambda-Funktionshandler in Node.js 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-Funktions-Handlern in Node.js arbeiten, einschließlich Optionen für die Projekteinrichtung, Benennungskonventionen und Best Practices. Diese Seite enthält auch ein Beispiel für eine Node.js-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. Informationen darüber, wie Sie Ihre Funktion nach dem Schreiben einsetzen können, finden Sie unter [Bereitstellen von Node.js Lambda-Funktionen mit ZIP-Dateiarchiven](nodejs-package.md) oder [Bereitstellen von Node.js-Lambda-Funktionen mit Container-Images](nodejs-image.md).
**Topics**
+ [
## Einrichten Ihres Node.js-Handler-Projekts
](#nodejs-handler-setup)
+ [
## Beispiel für Node.js-Lambda-Funktionscode
](#nodejs-example-code)
+ [
## CommonJS- und ES-Module
](#nodejs-commonjs-es-modules)
+ [
## Initialisierung von Node.js
](#nodejs-initialization)
+ [
## Namenskonventionen für Handler
](#nodejs-handler-naming)
+ [
## Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu
](#nodejs-example-input)
+ [
## Gültige Handler-Muster für Node.js-Funktionen
](#nodejs-handler-signatures)
+ [
## Verwenden Sie das SDK für JavaScript v3 in Ihrem Handler
](#nodejs-example-sdk-usage)
+ [
## Zugriff auf Umgebungsvariablen
](#nodejs-example-envvars)
+ [
## Verwenden des globalen Zustands
](#nodejs-handler-state)
+ [
## Bewährte Codemethoden für Node.js-Lambda-Funktionen
](#nodejs-best-practices)
## Einrichten Ihres Node.js-Handler-Projekts
Es gibt mehrere Möglichkeiten, ein Node.js-Lambda-Projekt zu initialisieren. Sie können beispielsweise ein Standard-Node.js-Projekt mit `npm` erstellen oder eine [AWS SAM -](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-init.html#using-sam-cli-init-new) bzw. [AWS CDK -Anwendung](lambda-cdk-tutorial.md#lambda-cdk-step-1) erstellen.
So erstellen Sie das Projekt mit `npm`:
```
npm init
```
Dieser Befehl initialisiert Ihr Projekt und generiert eine `package.json`-Datei, die die Metadaten und Abhängigkeiten Ihres Projekts verwaltet.
Ihr Funktionscode befindet sich in einer `.js` `.mjs` JavaScript OR-Datei. Im folgenden Beispiel nennen wir diese Datei `index.mjs`, weil sie einen ES-Modul-Handler verwendet. Lambda unterstützt sowohl ES-Modul- als auch CommonJS-Handler. Weitere Informationen finden Sie unter [CommonJS- und ES-Module](#nodejs-commonjs-es-modules).
Ein typisches Node.js-Lambda-Funktionsprojekt folgt dieser allgemeinen Struktur:
```
/project-root
├── index.mjs — Contains main handler
├── package.json — Project metadata and dependencies
├── package-lock.json — Dependency lock file
└── node_modules/ — Installed dependencies
```
## Beispiel für Node.js-Lambda-Funktionscode
Das folgende Beispiel für einen Lambda-Funktionscode nimmt Informationen über eine Bestellung auf, erstellt eine Textdateiquittung und platziert diese Datei in einem Amazon-S3-Bucket.
**Example Lambda-Funktion „index.mjs“**
```
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
// Initialize the S3 client outside the handler for reuse
const s3Client = new S3Client();
/**
* Lambda handler for processing orders and storing receipts in S3.
* @param {Object} event - Input event containing order details
* @param {string} event.order_id - The unique identifier for the order
* @param {number} event.amount - The order amount
* @param {string} event.item - The item purchased
* @returns {Promise} Success message
*/
export const handler = async(event) => {
try {
// Access environment variables
const bucketName = process.env.RECEIPT_BUCKET;
if (!bucketName) {
throw new Error('RECEIPT_BUCKET environment variable is not set');
}
// Create the receipt content and key destination
const receiptContent = `OrderID: ${event.order_id}\nAmount: $${event.amount.toFixed(2)}\nItem: ${event.item}`;
const key = `receipts/${event.order_id}.txt`;
// Upload the receipt to S3
await uploadReceiptToS3(bucketName, key, receiptContent);
console.log(`Successfully processed order ${event.order_id} and stored receipt in S3 bucket ${bucketName}`);
return 'Success';
} catch (error) {
console.error(`Failed to process order: ${error.message}`);
throw error;
}
};
/**
* Helper function to upload receipt to S3
* @param {string} bucketName - The S3 bucket name
* @param {string} key - The S3 object key
* @param {string} receiptContent - The content to upload
* @returns {Promise}
*/
async function uploadReceiptToS3(bucketName, key, receiptContent) {
try {
const command = new PutObjectCommand({
Bucket: bucketName,
Key: key,
Body: receiptContent
});
await s3Client.send(command);
} catch (error) {
throw new Error(`Failed to upload receipt to S3: ${error.message}`);
}
}
```
Diese `index.mjs`-Datei enthält die folgenden Abschnitte des Codes:
+ `import`-Block: Verwenden Sie diesen Block, um Bibliotheken einzubinden, die Ihre Lambda-Funktion benötigt, z. B. [AWS SDK-Clients](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/the-request-object.html).
+ `const s3Client`-Deklaration: Hiermit wird ein [Amazon-S3-Client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/) außerhalb der Handler-Funktion initialisiert. Dies veranlasst Lambda, diesen Code während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) auszuführen und der Client wird für die [Wiederverwendung über mehrere Aufrufe hinweg](lambda-runtime-environment.md#execution-environment-reuse) aufbewahrt.
+ JSDoc Kommentarblock: Definieren Sie die Eingabe- und Ausgabetypen für Ihren Handler mithilfe von [JSDoc Anmerkungen.](https://jsdoc.app/about-getting-started)
+ `export const handler`: Dies ist die Haupt-Handler-Funktion, die Lambda aufruft. Geben Sie beim Bereitstellen Ihrer Funktion `index.handler` für die [Handler](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler)-Eigenschaft an. Der Wert der Eigenschaft `Handler` besteht aus dem Dateinamen und dem Namen der exportierten Handler-Methode, getrennt durch einen Punkt.
+ `uploadReceiptToS3`-Funktion: Dies ist eine Hilfsfunktion, auf die von der Haupt-Handler-Funktion verwiesen wird.
Damit diese Funktion ordnungsgemäß funktioniert, muss ihre [Ausführungsrolle](lambda-intro-execution-role.md) die `s3:PutObject`-Aktion zulassen. Stellen Sie außerdem sicher, dass Sie die `RECEIPT_BUCKET`-Umgebungsvariable definieren. Nach einem erfolgreichen Aufruf sollte der Amazon-S3-Bucket eine Empfangsdatei enthalten.
## CommonJS- und ES-Module
Node.js unterstützt zwei Modulsysteme: CommonJS und ECMAScript Module (ES-Module). Lambda empfiehlt die Verwendung von ES-Modulen, da sie Await auf oberster Ebene unterstützen, wodurch asynchrone Aufgaben während der Initialisierung der [Ausführungsumgebung](#nodejs-initialization) abgeschlossen werden können.
Node.js behandelt Dateien mit einer `.cjs` Dateinamenerweiterung als CommonJS-Module, während eine `.mjs` Erweiterung ES-Module bezeichnet. Standardmäßig behandelt Node.js Dateien mit der `.js` Dateinamenerweiterung als CommonJS-Module. Sie können Node.js so konfigurieren, dass `.js` Dateien als ES-Module behandelt werden, indem Sie das `type` as `module` in der `package.json` Funktionsdatei angeben. Sie können Node.js in Lambda so konfigurieren, dass automatisch erkannt wird, ob eine `.js` Datei als CommonJS- oder als ES-Modul behandelt werden soll, indem Sie der `NODE_OPTIONS` Umgebungsvariablen das `—experimental-detect-module` Flag hinzufügen. Weitere Informationen finden Sie unter [Experimentelle Funktionen von Node.js](lambda-nodejs.md#nodejs-experimental-features).
Die folgenden Beispiele zeigen Funktionshandler, die sowohl mit ES-Modulen als auch mit CommonJS-Modulen geschrieben wurden. Die übrigen Beispiele auf dieser Seite verwenden alle ES-Module.
------
#### [ ES module example ]
**Example – ES-Modul-Handler**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
------
#### [ CommonJS module example ]
**Example – CommonJS-Modul-Handler**
```
const https = require("https");
let url = "https://aws.amazon.com/";
exports.handler = async function (event) {
let statusCode;
await new Promise(function (resolve, reject) {
https.get(url, (res) => {
statusCode = res.statusCode;
resolve(statusCode);
}).on("error", (e) => {
reject(Error(e));
});
});
console.log(statusCode);
return statusCode;
};
```
------
## Initialisierung von Node.js
Node.js verwendet ein nicht blockierendes I/O Modell, das effiziente asynchrone Operationen mithilfe einer Ereignisschleife unterstützt. Wenn Node.js beispielsweise einen Netzwerkaufruf tätigt, verarbeitet die Funktion weiterhin andere Operationen, ohne eine Netzwerkantwort zu blockieren. Wenn die Netzwerkantwort empfangen wird, wird sie in die Rückrufwarteschlange gestellt. Aufgaben aus der Warteschlange werden verarbeitet, wenn die aktuelle Aufgabe abgeschlossen ist.
Lambda empfiehlt die Verwendung von Await auf oberster Ebene, damit asynchrone Aufgaben, die während der Initialisierung der Ausführungsumgebung initiiert wurden, während der Initialisierung abgeschlossen werden. Asynchrone Aufgaben, die während der Initialisierung nicht abgeschlossen werden, werden normalerweise beim ersten Funktionsaufruf ausgeführt. Dies kann zu unerwartetem Verhalten oder Fehlern führen. Beispielsweise kann Ihre Funktionsinitialisierung einen Netzwerkaufruf ausführen, um einen Parameter aus dem AWS Parameterspeicher abzurufen. Wenn diese Aufgabe während der Initialisierung nicht abgeschlossen wird, kann der Wert während eines Aufrufs Null sein. Es kann auch zu einer Verzögerung zwischen der Initialisierung und dem Aufruf kommen, was bei zeitkritischen Vorgängen zu Fehlern führen kann. Insbesondere AWS Serviceabrufe können sich auf zeitkritische Anforderungssignaturen stützen, was dazu führt, dass Serviceabrufe fehlschlagen, wenn der Anruf während der Initialisierungsphase nicht abgeschlossen wird. Das Abschließen von Aufgaben während der Initialisierung verbessert in der Regel die Kaltstartleistung und die Leistung beim ersten Aufrufen, wenn Provisioned Concurrency verwendet wird. Weitere Informationen finden Sie in unserem Blogbeitrag Using [Node.js ES modules and top](https://aws.amazon.com/blogs/compute/using-node-js-es-modules-and-top-level-await-in-aws-lambda) level await in. AWS Lambda
## Namenskonventionen für Handler
Wenn Sie eine Funktion konfigurieren, besteht der Wert der [Handler](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler)-Einstellung aus dem Dateinamen und dem Namen der exportierten Handler-Methode, getrennt durch einen Punkt. Der Standardwert für Funktionen, die in der Konsole erstellt werden und für die Beispiele in diesem Handbuch ist `index.handler`. Dies deutet auf die `handler`-Methode hin, die aus der `index.js`- oder `index.mjs`-Datei wurde.
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**.
## Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu
JSON ist das gebräuchlichste und standardmäßigste Eingabeformat für Lambda-Funktionen. In diesem Beispiel erwartet die Funktion eine Eingabe ähnlich der folgenden:
```
{
"order_id": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}
```
Wenn Sie mit Lambda-Funktionen in Node.js arbeiten, können Sie die erwartete Form des Eingabeereignisses mithilfe von JSDoc Anmerkungen definieren. In diesem Beispiel definieren wir die Eingabestruktur im Kommentar des Handlers JSDoc :
```
/**
* Lambda handler for processing orders and storing receipts in S3.
* @param {Object} event - Input event containing order details
* @param {string} event.order_id - The unique identifier for the order
* @param {number} event.amount - The order amount
* @param {string} event.item - The item purchased
* @returns {Promise} Success message
*/
```
Nachdem Sie diese Typen in Ihrem JSDoc Kommentar definiert haben, können Sie direkt in Ihrem Code auf die Felder des Event-Objekts zugreifen. Zum Beispiel holt `event.order_id` den Wert von `order_id` aus der ursprünglichen Eingabe.
## Gültige Handler-Muster für Node.js-Funktionen
[Wir empfehlen, dass Sie [async/await](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/using-async-await.html) verwenden, um den Funktionshandler zu deklarieren, anstatt Callbacks zu verwenden.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/using-a-callback-function.html) Async/await ist eine präzise und lesbare Methode, asynchronen Code zu schreiben, ohne dass verschachtelte Callbacks oder verkettete Zusagen erforderlich sind. Mit Async/Await können Sie Code schreiben, der sich wie synchroner Code liest, aber dennoch asynchron und blockierungsfrei ist.
### Handler für asynchrone Funktionen (empfohlen)
Das `async`-Schlüsselwort kennzeichnet eine Funktion als asynchron, und das `await`-Schlüsselwort unterbricht die Ausführung der Funktion, bis `Promise` aufgelöst ist. Der Handler akzeptiert die folgenden Argumente:
+ `event`: Enthält die an Ihre Funktion übergebenen Eingabedaten.
+ `context`: Enthält Informationen über den Aufruf, die Funktion und die Ausführungsumgebung. Weitere Informationen finden Sie unter [Verwenden des Lambda-Kontextobjekts zum Abrufen von Node.js-Funktionsinformationen](nodejs-context.md).
Hier sind die gültigen Signaturen für das async/await Muster:
```
export const handler = async (event) => { };
```
```
export const handler = async (event, context) => { };
```
### Handler für synchrone Funktionen
Wenn Ihre Funktion keine asynchronen Aufgaben ausführt, können Sie einen synchronen Funktionshandler verwenden, der eine der folgenden Funktionssignaturen verwendet:
```
export const handler = (event) => { };
```
```
export const handler = (event, context) => { };
```
### Handler für Antwort-Streaming-Funktionen
Lambda unterstützt Response-Streaming mit Node.js. Handler für Antwort-Streaming-Funktionen verwenden den `awslambda.streamifyResponse()` Decorator und verwenden 3 Parameter:`event`, `responseStream` und. `context` Die Funktionssignatur lautet:
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, context) => { });
```
Weitere Informationen finden Sie unter [Antwortstreaming für Lambda-Funktionen](configuration-response-streaming.md).
### Callback-basierte Funktionshandler
**Anmerkung**
Callback-basierte Funktionshandler werden nur bis zu Node.js 22 unterstützt. Ab Node.js 24 sollten asynchrone Aufgaben mithilfe von asynchronen Funktionshandlern implementiert werden.
Callback-basierte Funktionshandler müssen die Event-, Kontext- und Callback-Argumente verwenden. Beispiel:
```
export const handler = (event, context, callback) => { };
```
Die Callback-Funktion erwartet `Error` und eine Antwort, die JSON-serialisierbar sein muss. Die Funktion wird so lange ausgeführt, bis die [Ereignisschleife](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/) leer ist oder ein Timeout auftritt. Die Antwort wird erst an den Aufrufer gesendet, wenn alle Ereignisschleifenaufgaben abgeschlossen sind. Wenn eine Zeitüberschreitung der Funktion auftritt, wird stattdessen ein Fehler zurückgegeben. [Sie können die Laufzeit so konfigurieren, dass die Antwort sofort gesendet wird, indem Sie den Kontext festlegen. callbackWaitsForEmptyEventLoop](nodejs-context.md)auf „Falsch“ setzen.
**Example – HTTP-Anforderung mit callback**
Die folgende Beispielfunktion prüft eine URL und gibt den Statuscode an den Aufrufer zurück.
```
import https from "https";
let url = "https://aws.amazon.com/";
export const handler = (event, context, callback) => {
https.get(url, (res) => {
callback(null, res.statusCode);
}).on("error", (e) => {
callback(Error(e));
});
};
```
## Verwenden Sie das SDK für JavaScript v3 in Ihrem Handler
Oft verwenden Sie Lambda-Funktionen, um mit anderen AWS Ressourcen zu interagieren oder diese zu aktualisieren. Die einfachste Art, eine Schnittstelle zu diesen Ressourcen herzustellen, ist die Verwendung von AWS SDK für JavaScript. Alle [unterstützten Lambda Node.js Runtimes](lambda-nodejs.md#nodejs-supported-runtimes) enthalten das [SDK für JavaScript Version 3.](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/) Wir empfehlen jedoch dringend, dass Sie die benötigten AWS SDK-Clients in Ihr Bereitstellungspaket aufnehmen. Dadurch wird die [Abwärtskompatibilität](runtimes-update.md#runtime-update-compatibility) bei zukünftigen Lambda-Laufzeit-Updates maximiert. Verlassen Sie sich nur dann auf das von der Laufzeit bereitgestellte SDK, wenn Sie keine zusätzlichen Pakete hinzufügen können (z. B. wenn Sie den Code-Editor der Lambda-Konsole oder Inline-Code in einer AWS CloudFormation Vorlage verwenden).
Um Ihrer Funktion SDK-Abhängigkeiten hinzuzufügen, verwenden Sie den `npm install`-Befehl für die spezifischen SDK-Clients, die Sie benötigen. Im Beispielcode haben wir den [Amazon-S3-Client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/) verwendet. Fügen Sie diese Abhängigkeit hinzu, indem Sie den folgenden Befehl in dem Verzeichnis ausführen, das Ihre `package.json`-Datei enthält:
```
npm install @aws-sdk/client-s3
```
Importieren Sie im Funktionscode den Client und die Befehle, die Sie benötigen, wie in der Beispielfunktion gezeigt:
```
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
```
Initialisieren Sie dann einen [Amazon-S3-Client](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/):
```
const s3Client = new S3Client();
```
In diesem Beispiel haben wir unseren Amazon-S3-Client außerhalb der Haupt-Handler-Funktion initialisiert, um zu vermeiden, dass wir ihn bei jedem Aufruf unserer Funktion initialisieren müssen. Nachdem Sie Ihren SDK-Client initialisiert haben, können Sie ihn verwenden, um API-Aufrufe für diesen Dienst zu tätigen. AWS Der Beispielcode ruft die Amazon S3 [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/)S3-API-Aktion wie folgt auf:
```
const command = new PutObjectCommand({
Bucket: bucketName,
Key: key,
Body: receiptContent
});
```
## Zugriff auf Umgebungsvariablen
In Ihrem Handler-Code können Sie mithilfe von `process.env` auf beliebige [Umgebungsvariablen](configuration-envvars.md) verweisen. In diesem Beispiel verweisen wir mit den folgenden Codezeilen auf die definierte `RECEIPT_BUCKET`-Umgebungsvariable:
```
// Access environment variables
const bucketName = process.env.RECEIPT_BUCKET;
if (!bucketName) {
throw new Error('RECEIPT_BUCKET environment variable is not set');
}
```
## Verwenden des globalen Zustands
Lambda führt Ihren statischen Code während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) aus, bevor Ihre Funktion zum ersten Mal aufgerufen wird. Ressourcen, die während der Initialisierung erstellt werden, bleiben zwischen Aufrufen im Speicher, sodass Sie sie nicht bei jedem Aufruf Ihrer Funktion neu erstellen müssen.
Im Beispielcode befindet sich der Initialisierungscode des S3-Clients außerhalb des Handlers. Die Laufzeit initialisiert den Client, bevor die Funktion ihr erstes Ereignis ausführt, und der Client bleibt für die Wiederverwendung bei allen Aufrufen verfügbar.
## Bewährte Codemethoden für Node.js-Lambda-Funktionen
Befolgen Sie diese Richtlinien, wenn Sie Lambda-Funktionen erstellen:
+ **Trennen Sie den Lambda-Handler von Ihrer Core-Logik.** Auf diese Weise können Sie eine Funktion zur besseren Prüfbarkeit von Einheiten schaffen.
+ **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 APIs in Ihrem Lambda-Funktionscode nicht undokumentiert, nicht öffentlich**. Für AWS Lambda verwaltete Laufzeiten führt Lambda regelmäßig Sicherheits- und Funktionsupdates für interne Lambda-Laufzeiten durch. APIs Diese internen API-Updates können abwärtsinkompatibel sein, was zu unbeabsichtigten Folgen wie Aufruffehlern führen kann, wenn Ihre Funktion von diesen nicht öffentlichen Daten abhängig ist. APIs Eine Liste [der öffentlich verfügbaren Programme finden Sie in der API-Referenz.](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) APIs
**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/).
# Bereitstellen von Node.js Lambda-Funktionen mit ZIP-Dateiarchiven
Der Code Ihrer AWS Lambda Funktion besteht aus einer .js- oder .mjs-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 Node.js finden Sie unter [Bereitstellen von Node.js-Lambda-Funktionen mit Container-Images](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-image.html).
Zum Erstellen des Bereitstellungspakets für ein ZIP-Dateiarchiv können Sie ein integriertes Dienstprogramm für ZIP-Dateien Ihres Befehlszeilen-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 Node.js
](#nodejs-package-dependencies)
+ [
## ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen
](#nodejs-package-create-no-dependencies)
+ [
## ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen
](#nodejs-package-create-dependencies)
+ [
## Erstellen einer Node.js-Ebene für Ihre Abhängigkeiten
](#nodejs-package-dependencies-layers)
+ [
## Suchpfad für Abhängigkeiten und integrierte Laufzeit-Bibliotheken
](#nodejs-package-searchpath)
+ [
## Erstellen und Aktualisieren von Node.js-Lambda-Funktionen mithilfe von ZIP-Dateien
](#nodejs-package-create-update)
## Laufzeitabhängigkeiten in Node.js
Für Lambda-Funktionen, die die Node.js-Laufzeit verwenden, kann eine Abhängigkeit ein beliebiges Node.js-Modul sein. Die Laufzeitumgebung von Node.js enthält eine Reihe gängiger Bibliotheken sowie eine Version des AWS SDK für JavaScript. Alle [unterstützten Node.js-Laufzeiten](lambda-nodejs.md#nodejs-supported-runtimes) beinhalten Version 3 des SDK. Um Version 2 des SDK zu verwenden, müssen Sie das SDK zu Ihrem ZIP-Dateibereitstellungspaket hinzufügen. Die spezifische Version des SDK, die in der von Ihnen verwendeten Laufzeit enthalten ist, finden Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](lambda-nodejs.md#nodejs-sdk-included).
Lambda aktualisiert die SDK-Bibliotheken in der Node.js-Laufzeit regelmäßig, um die aktuellen Features und Sicherheitsupgrades aufzunehmen. Lambda wendet auch Sicherheitspatches und Updates auf die anderen in der Laufzeit enthaltenen Bibliotheken an. Um die volle Kontrolle über die Abhängigkeiten in Ihrem Paket zu haben, können Sie Ihrem Bereitstellungspaket Ihre bevorzugte Version einer beliebigen in die Laufzeit eingeschlossenen Abhängigkeit hinzufügen. Wenn Sie beispielsweise eine bestimmte Version des SDK verwenden möchten JavaScript, können Sie sie als Abhängigkeit in Ihre ZIP-Datei aufnehmen. Weitere Informationen zum Hinzufügen von in die Laufzeit eingeschlossene Abhängigkeiten zu Ihrer ZIP-Datei finden Sie unter [Suchpfad für Abhängigkeiten und integrierte Laufzeit-Bibliotheken](#nodejs-package-searchpath).
Im Rahmen des [AWS -Modells der geteilten Verantwortung](lambda-runtimes.md#runtimes-shared-responsibility) 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](#nodejs-package-create-dependencies) und [Erstellen und Aktualisieren von Node.js-Lambda-Funktionen mithilfe von ZIP-Dateien](#nodejs-package-create-update).
## ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen
Wenn Ihr Funktionscode neben den in der Lambda-Laufzeit eingeschlossenen Bibliotheken keine Abhängigkeiten hat, enthält Ihre ZIP-Datei nur die `index.js`- oder `index.mjs`-Datei mit dem Handler-Code Ihrer Funktion. Erstellen Sie mit Ihrem bevorzugten ZIP-Programm eine ZIP-Datei mit Ihrer `index.js`- oder `index.mjs`-Datei im Stammverzeichnis. Wenn sich die Datei mit Ihrem Handler-Code 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 [Erstellen und Aktualisieren von Node.js-Lambda-Funktionen mithilfe von ZIP-Dateien](#nodejs-package-create-update).
## ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen
Wenn Ihr Funktionscode von Paketen oder Modulen abhängt, die nicht in der Lambda-Node.js-Laufzeit enthalten sind, können Sie diese Abhängigkeiten entweder mit Ihrem Funktionscode zu Ihrer ZIP-Datei hinzufügen oder eine [Lambda-Ebene](chapter-layers.md) verwenden. Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie Ihre Abhängigkeiten in Ihr ZIP-Bereitstellungspaket aufnehmen. Anweisungen zum Einschließen Ihrer Abhängigkeiten in eine Ebene finden Sie unter [Erstellen einer Node.js-Ebene für Ihre Abhängigkeiten](#nodejs-package-dependencies-layers).
Die folgenden CLI-Befehle erstellen Sie eine ZIP-Datei mit dem Namen `my_deployment_package.zip`, welche die `index.js`- oder `index.mjs`-Datei mit dem Handler-Code Ihrer Funktion und die zugehörigen Abhängigkeiten enthält. Im Beispiel installieren Sie Abhängigkeiten mit dem npm-Paketmanager.
**Erstellen des Bereitstellungspakets**
1. Navigieren Sie zum Projektverzeichnis, das Ihre Quellcodedatei `index.js` oder `index.mjs` enthält. In diesem Beispiel trägt das Verzeichnis den Namen `my_function`.
```
cd my_function
```
1. Installieren Sie die erforderlichen Bibliotheken Ihrer Funktion im Verzeichnis `node_modules` mit dem Befehl `npm install`. In diesem Beispiel installieren Sie das AWS X-Ray-SDK für Node.js.
```
npm install aws-xray-sdk
```
Dabei wird eine Ordnerstruktur erstellt, die etwa wie folgt aussieht:
```
~/my_function
├── index.mjs
└── node_modules
├── async
├── async-listener
├── atomic-batcher
├── aws-sdk
├── aws-xray-sdk
├── aws-xray-sdk-core
```
Sie können Ihrem Bereitstellungspaket auch benutzerdefinierte Module hinzufügen, die Sie selbst erstellen. Erstellen Sie ein Verzeichnis unter `node_modules` mit dem Namen Ihres Moduls und speichern Sie Ihre benutzerdefinierten geschriebenen Pakete dort.
1. Erstellen Sie im Stammverzeichnis eine ZIP-Datei mit den Inhalten Ihres Projektordners. Benutzen Sie die `r` (rekursive) Option, um sicherzustellen, dass der zip-Befehl die Unterordner komprimiert.
```
zip -r my_deployment_package.zip .
```
## Erstellen einer Node.js-Ebene für Ihre Abhängigkeiten
Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie Ihre Abhängigkeiten in eine Ebene einschließen. Anweisungen zum Einschließen Ihrer Abhängigkeiten in Ihr Bereitstellungspaket finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](#nodejs-package-create-dependencies).
Wenn Sie einer Funktion eine Ebene hinzufügen, lädt Lambda den Ebeneninhalt in das Verzeichnis `/opt` der Ausführungsumgebung. Für jede Lambda-Laufzeit enthält die Variable `PATH` bereits spezifische Ordnerpfade innerhalb des Verzeichnisses `/opt`. Um sicherzustellen, dass Lambda den Inhalt Ihrer Ebene aufnimmt, müssen die Abhängigkeiten Ihrer ZIP-Datei in einem der folgenden Ordnerpfade enthalten sein:
+ `nodejs/node_modules`
+ `nodejs/node18/node_modules (NODE_PATH)`
+ `nodejs/node20/node_modules (NODE_PATH)`
+ `nodejs/node22/node_modules (NODE_PATH)`
Die Struktur Ihrer Ebene-ZIP-Datei könnte beispielsweise wie folgt aussehen:
```
xray-sdk.zip
└ nodejs/node_modules/aws-xray-sdk
```
Darüber hinaus erkennt Lambda automatisch alle Bibliotheken im `/opt/lib`-Verzeichnis und alle Binärdateien im `/opt/bin`-Verzeichnis. Um sicherzustellen, dass Lambda Ihren Ebeneninhalt korrekt findet, können Sie auch eine Ebene mit der folgenden Struktur erstellen:
```
custom-layer.zip
└ lib
| lib_1
| lib_2
└ bin
| bin_1
| bin_2
```
Nachdem Sie Ihre Ebene gebündelt haben, sehen Sie sich [Erstellen und Löschen von Ebenen in Lambda](creating-deleting-layers.md) und [Hinzufügen von Ebenen zu Funktionen](adding-layers.md) an, um die Einrichtung Ihrer Ebene abzuschließen.
## Suchpfad für Abhängigkeiten und integrierte Laufzeit-Bibliotheken
Die Laufzeitumgebung von Node.js enthält eine Reihe gängiger Bibliotheken sowie eine Version des AWS SDK für JavaScript. Wenn Sie eine andere Version einer in die Laufzeit eingeschlossenen Bibliothek verwenden möchten, können Sie sie mit Ihrer Funktion bündeln oder sie als Abhängigkeit zu Ihrem Bereitstellungspaket hinzufügen. Sie können beispielsweise eine andere Version des SDK verwenden, indem Sie es Ihrem ZIP-Bereitstellungspaket hinzufügen. Sie können sie auch in eine [Lambda-Ebene](chapter-layers.md) für Ihre Funktion aufnehmen.
Wenn Sie in Ihrem Code eine `import`- oder `require`-Anweisung verwenden, durchsucht die Node.js-Laufzeit die Verzeichnisse im `NODE_PATH`-Pfad, bis das Modul gefunden wird. Standardmäßig ist der erste Speicherort, den die Laufzeit durchsucht, das Verzeichnis, in das Ihr ZIP-Bereitstellungspaket entpackt und bereitgestellt wird (`/var/task`). Nehmen Sie eine Version einer in der Laufzeit integrierten Bibliothek in Ihr Bereitstellungspaket auf, hat diese Version Vorrang vor der in der Laufzeit enthaltenen. 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/nodejs/nodexx/node_modules`, wobei `nodexx` die von Ihnen verwendete Version der Laufzeitumgebung ist. Im Suchpfad hat dieses Verzeichnis Vorrang vor dem Verzeichnis mit den zur Laufzeit enthaltenen Bibliotheken (`/var/lang/lib/node_modules`). Bibliotheken in Funktionsebenen haben daher Vorrang vor Versionen, die in der Laufzeit enthalten sind.
Sie können den vollständigen Suchpfad für Ihre Lambda-Funktion sehen, indem Sie die folgende Codezeile hinzufügen:
```
console.log(process.env.NODE_PATH)
```
Fügen Sie Abhängigkeiten alternativ auch in einem separaten Ordner in Ihrem ZIP-Paket hinzu. Fügen Sie beispielsweise eine benutzerdefinierte Version 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. Um eine Abhängigkeit von einem Ordner in Ihrem ZIP-Bereitstellungspaket in Ihrem Code zu verwenden, verwenden Sie eine `import { } from`- oder `const { } = require()`-Anweisung, je nachdem, ob Sie die CJS- oder die ESM-Modulauflösung verwenden. Beispiel:
```
import { myModule } from './common'
```
Wenn Sie Ihren Code mit `esbuild`, `rollup` oder ähnlichem bündeln, werden die von Ihrer Funktion verwendeten Abhängigkeiten in einer oder mehreren Dateien gebündelt. Wir empfehlen, diese Methode zu verwenden, um Abhängigkeiten wann immer möglich zu vergeben. Im Vergleich zum Hinzufügen von Abhängigkeiten zu Ihrem Bereitstellungspaket führt das Bündeln Ihres Codes aufgrund der Reduzierung der Betriebsabläufe zu einer I/O Leistungssteigerung.
## Erstellen und Aktualisieren von Node.js-Lambda-Funktionen mithilfe von ZIP-Dateien
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 nodejs24.x --handler index.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 nodejs24.x --handler index.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*
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
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 Node.js-Lambda-Funktionen mit Container-Images
Es gibt drei Möglichkeiten, ein Container-Image für eine Node.js-Lambda-Funktion zu erstellen:
+ [Verwenden Sie ein AWS Basis-Image für Node.js](#nodejs-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 Node.js](#nodejs-image-clients) in das Image aufnehmen.
+ [Verwenden Sie ein Image, das nicht zur Basisversion gehört AWS ](#nodejs-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 Node.js](#nodejs-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 Basis-Images für Node.js
](#nodejs-image-base)
+ [
## Verwenden Sie ein AWS Basis-Image für Node.js
](#nodejs-image-instructions)
+ [
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
](#nodejs-image-clients)
## AWS Basis-Images für Node.js
AWS stellt die folgenden Basis-Images für Node.js bereit:
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| 24 | Node.js 24 | Amazon Linux 2023 | [Dockerfile für Node.js 24 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs24.x/Dockerfile.nodejs24.x) | 30. April 2028 |
| 22 | Node.js 22 | Amazon Linux 2023 | [Dockerfile für Node.js 22 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs22.x/Dockerfile.nodejs22.x) | 30. April 2027 |
| 20 | Node.js 20 | Amazon Linux 2023 | [Dockerfile für Node.js 2.0 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs20.x/Dockerfile.nodejs20.x) | 30. April 2026 |
Amazon ECR-Repository: [gallery.ecr. aws/lambda/nodejs](https://gallery.ecr.aws/lambda/nodejs)
Die Basis-Images von Node.js 20 und höher basieren auf dem [minimalen Container-Image von Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Frühere Basis-Images verwenden Amazon Linux 2. AL2023 bietet 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.
## Verwenden Sie ein AWS Basis-Image für Node.js
### 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).
+ Node.js
### Erstellen eines Images aus einem Base Image
**Um ein Container-Image aus einem AWS Basis-Image für Node.js 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 ein neues Node.js-Projekt mit `npm`. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
```
npm init
```
1. Erstellen Sie eine neue Datei mit dem Namen `index.js`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example CommonJS-Handler**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Wenn Ihre Funktion von anderen Bibliotheken als den abhängt AWS SDK für JavaScript, verwenden Sie [npm](https://www.npmjs.com/), um sie Ihrem Paket hinzuzufügen.
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/nodejs).
+ 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/nodejs:22
# Copy function code
COPY index.js ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "index.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 Node.js](https://www.npmjs.com/package/aws-lambda-ric) mit dem npm-Paketmanager:
```
npm install aws-lambda-ric
```
Sie können den [Runtime Interface-Client von Node.js](https://github.com/aws/aws-lambda-nodejs-runtime-interface-client) auch herunterladen GitHub.
Das folgende Beispiel zeigt, wie ein Container-Image für Node.js mithilfe eines AWS Nicht-Basis-Images erstellt wird. Das Beispiel-Dockerfile verwendet ein `bookworm`-Basis-Image. Das Docker-File enthält den Laufzeitschnittstellen-Client.
### 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).
+ Node.js
### 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 ein neues Node.js-Projekt mit `npm`. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
```
npm init
```
1. Erstellen Sie eine neue Datei mit dem Namen `index.js`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example CommonJS-Handler**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Erstellen Sie eine neue Docker-Datei. Das folgende Dockerfile verwendet ein `bookworm`-Basis-Image anstelle eines [AWS -Basis-Images](images-create.md#runtimes-images-lp). Das Dockerfile enthält den [Laufzeitschnittstellen-Client](https://www.npmjs.com/package/aws-lambda-ric), der das Image mit Lambda kompatibel macht. Das folgende Dockerfile verwendet einen [Build mit mehreren Phasen](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). In der ersten Phase wird ein Build-Image erstellt, bei dem es sich um eine Standardumgebung von Node.js handelt, in der die Abhängigkeiten der Funktion installiert werden. In der zweiten Phase wird ein schlankeres Image erstellt, das den Funktionscode und seine Abhängigkeiten enthält. Dadurch wird die endgültige Image-Größe reduziert.
+ Legen Sie `FROM`-Eigenschaft auf die Kennung des Basis-Images fest.
+ Verwenden Sie den Befehl `COPY`, um den Funktionscode und die Laufzeitabhängigkeiten zu kopieren.
+ 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 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**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM node:20-bookworm as build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Install build dependencies
RUN apt-get update && \
apt-get install -y \
g++ \
make \
cmake \
unzip \
libcurl4-openssl-dev
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
WORKDIR ${FUNCTION_DIR}
# Install Node.js dependencies
RUN npm install
# Install the runtime interface client
RUN npm install aws-lambda-ric
# Grab a fresh slim copy of the image to reduce the final size
FROM node:20-bookworm-slim
# Required for Node runtimes which use npm@8.6.0+ because
# by default npm writes logs under /home/.npm and Lambda fs is read-only
ENV NPM_CONFIG_CACHE=/tmp/.npm
# 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/npx", "aws-lambda-ric"]
# Pass the name of the function handler as an argument to the runtime
CMD ["index.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/npx aws-lambda-ric index.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/npx aws-lambda-ric index.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/npx aws-lambda-ric index.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
```
# Arbeiten mit Ebenen für Node.js 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
](#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
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
**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
**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
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
------
#### [ 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-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.
# Verwenden des Lambda-Kontextobjekts zum Abrufen von Node.js-Funktionsinformationen
Wenn Lambda Ihre Funktion ausführt, wird ein Context-Objekt an den [Handler](nodejs-handler.md). übergeben. Dieses Objekt stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereit.
**Context-Methoden**
+ `getRemainingTimeInMillis()` – Gibt die Anzahl der verbleibenden Millisekunden zurück, bevor die Ausführung das Zeitlimit überschreitet.
**Context-Eigenschaften**
+ `functionName` – Der Name der Lambda-Funktion.
+ `functionVersion` – Die [Version](configuration-versions.md) der Funktion.
+ `invokedFunctionArn` – Der Amazon-Ressourcenname (ARN), der zum Aufrufen der Funktion verwendet wird. Gibt an, ob der Aufrufer eine Versionsnummer oder einen Alias angegeben hat.
+ `memoryLimitInMB` – Die Menge an Arbeitsspeicher, die der Funktion zugewiesen ist.
+ `awsRequestId` – Der Bezeichner der Aufrufanforderung.
+ `logGroupName` – Protokollgruppe für die Funktion.
+ `logStreamName` – Der Protokollstream für die Funktions-Instance.
+ `identity` – Informationen zur Amazon-Cognito-Identität, die die Anforderung autorisiert hat.
+ `cognitoIdentityId`— Die authentifizierte Amazon-Cognito-Identität.
+ `cognitoIdentityPoolId` – Der Amazon-Cognito-Identitätspool, der den Aufruf autorisiert hat.
+ `clientContext` – (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`
+ `env.platform_version`
+ `env.platform`
+ `env.make`
+ `env.model`
+ `env.locale`
+ `custom` – Benutzerdefinierte Werte, die durch die mobilen Anwendung festgelegt werden.
+ `callbackWaitsForEmptyEventLoop`— Standardmäßig (`true`) wartet Lambda bei Verwendung eines Callback-basierten Funktionshandlers darauf, dass die Ereignisschleife leer ist, nachdem der Callback ausgeführt wurde, bevor der Funktionsaufruf beendet wird. Legt fest, dass `false` die Antwort gesendet und der Aufruf sofort beendet wird, nachdem der Callback ausgeführt wurde, anstatt darauf zu warten, dass die Event-Schleife leer ist. Ausstehende Ereignisse werden beim nächsten Aufruf weiterhin ausgeführt. Beachten Sie, dass Lambda Callback-basierte Funktionshandler nur für Node.js 22 und frühere Laufzeiten unterstützt.
Die folgende Beispielfunktion protokolliert Kontextinformationen und gibt den Speicherort der Protokolle zurück.
**Example Datei index.js**
```
exports.handler = async function(event, context) {
console.log('Remaining time: ', context.getRemainingTimeInMillis())
console.log('Function name: ', context.functionName)
return context.logStreamName
}
```
# Node.js-Lambda-Funktionen protokollieren und überwachen
AWS Lambda überwacht automatisch Lambda-Funktionen in Ihrem Namen und sendet Protokolle 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 finden Sie unter [Senden von Lambda-Funktionsprotokollen an CloudWatch Logs](monitoring-cloudwatchlogs.md).
Auf dieser Seite wird beschrieben, wie Sie aus dem Code Ihrer Lambda-Funktion eine Protokollausgabe erstellen und mit der AWS Command Line Interface Lambda-Konsole oder der CloudWatch Konsole auf Logs zugreifen.
**Topics**
+ [
## Erstellen einer Funktion, die Protokolle zurückgibt
](#node-logging-output)
+ [
## Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Node.js
](#node-js-logging-advanced)
+ [
## Anzeigen von Protokollen in der Lambda-Konsole
](#nodejs-logging-console)
+ [
## Protokolle in der Konsole anzeigen CloudWatch
](#nodejs-logging-cwconsole)
+ [
## Logs mit dem Befehl () anzeigen AWS Command Line Interface AWS CLI
](#nodejs-logging-cli)
+ [
## Löschen von Protokollen
](#nodejs-logging-delete)
## Erstellen einer Funktion, die Protokolle zurückgibt
Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie Methoden auf dem [Konsolenobjekt](https://developer.mozilla.org/en-US/docs/Web/API/Console) oder eine Protokollierungsbibliothek verwenden, die zu `stdout` oder `stderr` schreibt. Das folgende Beispiel protokolliert die Werte der Umgebungsvariablen und des Ereignisobjekts.
**Anmerkung**
Wir empfehlen, bei der Protokollierung von Eingaben Techniken wie Eingabevalidierung und Ausgabekodierung zu verwenden. Wenn Sie Eingabedaten direkt protokollieren, kann ein Angreifer Ihren Code verwenden, um Manipulationen schwer zu erkennen, Protokolleinträge zu fälschen oder Protokollüberwachungen zu umgehen. Weitere Informationen finden Sie unter [Unsachgemäße Neutralisierung der Ausgabe von Protokollen](https://cwe.mitre.org/data/definitions/117.html) in der *Common Weakness Enumeration*.
**Example Datei index.js – Protokollierung**
```
exports.handler = async function(event, context) {
console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
console.info("EVENT\n" + JSON.stringify(event, null, 2))
console.warn("Event not processed.")
return context.logStreamName
}
```
**Example Protokollformat**
```
START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST
2019-06-07T19:11:20.562Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO ENVIRONMENT VARIABLES
{
"AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
"AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
"AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
"AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
"AWS_LAMBDA_FUNCTION_NAME": "my-function",
"PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
"NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/node_modules",
...
}
2019-06-07T19:11:20.563Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO EVENT
{
"key": "value"
}
2019-06-07T19:11:20.564Z c793869b-ee49-115b-a5b6-4fd21e8dedac WARN Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Duration: 128.83 ms Billed Duration: 296 ms Memory Size: 128 MB Max Memory Used: 74 MB Init Duration: 166.62 ms XRAY TraceId: 1-5d9d007f-0a8c7fd02xmpl480aed55ef0 SegmentId: 3d752xmpl1bbe37e Sampled: true
```
Die Node.js-Laufzeit protokolliert die Zeilen `START`, `END`, und `REPORT` für jeden Aufruf. Sie fügt jedem von der Funktion protokollierten Eintrag einen Zeitstempel, eine Anforderungs-ID und eine Protokollebene hinzu. Die Berichtszeile enthält die folgenden Details.
**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.
Sie können Logs in der Lambda-Konsole, in der CloudWatch Logs-Konsole oder über die Befehlszeile anzeigen.
## Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Node.js
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 Node.js-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).
Informationen zur Verwendung der Optionen für das Protokollformat und die Protokollebene mit Ihren Node.js-Lambda-Funktionen finden Sie in den folgenden Abschnitten.
### Verwenden strukturierter JSON-Protokolle mit Node.js
Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die Protokollausgabe mit den Konsolenmethoden`console.trace`,,`console.debug`, `console.log` `console.info``console.error`, und `console.warn` an CloudWatch als strukturiertes JSON. 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
Abhängig von der Protokollierungsmethode, die Ihre Funktion verwendet, kann dieses JSON-Objekt auch zusätzliche Schlüsselpaare enthalten. Wenn Ihre Funktion beispielsweise `console`-Methoden verwendet, um Fehlerobjekte mit mehreren Argumenten zu protokollieren, enthält das JSON-Objekt zusätzliche Schlüssel-Wert-Paare mit den Schlüsseln `errorMessage`, `errorType` und `stackTrace`.
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. Lambda codiert Protokolle, die bereits JSON-codiert sind, nicht doppelt, sodass die Anwendungsprotokolle Ihrer Funktion weiterhin wie zuvor erfasst werden.
Weitere Informationen zur Verwendung des Pakets Powertools for AWS Lambda Logging zur Erstellung strukturierter JSON-Logs in der Laufzeit von Node.js finden Sie unter. [TypeScript Lambda-Funktionen protokollieren und überwachen](typescript-logging.md)
#### Beispiel für Protokollausgaben im JSON-Format
Die folgenden Beispiele zeigen, wie verschiedene Protokollausgaben, die mithilfe der `console` Methoden mit einzelnen und mehreren Argumenten generiert wurden, in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion auf JSON setzen.
Im ersten Beispiel wird die `console.error`-Methode verwendet, um eine einfache Zeichenfolge auszugeben.
**Example Protokollcode für Node.js**
```
export const handler = async (event) => {
console.error("This is a warning message");
...
}
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp":"2025-11-01T00:21:51.358Z",
"level":"ERROR",
"message":"This is a warning message",
"requestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}
```
Sie können mit den `console`-Methoden auch komplexere strukturierte Protokollnachrichten ausgeben, indem Sie entweder einzelne oder mehrere Argumente verwenden. Im nächsten Beispiel verwenden Sie `console.log`, um zwei Schlüssel-Wert-Paare mit einem einzigen Argument auszugeben. Beachten Sie, dass das `"message"` Feld im JSON-Objekt, das Lambda an CloudWatch Logs sendet, nicht stringifiziert ist.
**Example Protokollcode für Node.js**
```
export const handler = async (event) => {
console.log({data: 12.3, flag: false});
...
}
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp": "2025-12-08T23:21:04.664Z",
"level": "INFO",
"requestId": "405a4537-9226-4216-ac59-64381ec8654a",
"message": {
"data": 12.3,
"flag": false
}
}
```
Im nächsten Beispiel verwenden Sie erneut die `console.log`-Methode, um eine Protokollausgabe zu erstellen. Diesmal verwendet die Methode zwei Argumente, eine Map mit zwei Schlüssel-Wert-Paaren und eine identifizierende Zeichenfolge. Beachten Sie, dass Lambda in diesem Fall das Feld `"message"` in eine Zeichenfolge umwandelt, da Sie zwei Argumente angegeben haben.
**Example Protokollcode für Node.js**
```
export const handler = async (event) => {
console.log('Some object - ', {data: 12.3, flag: false});
...
}
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp": "2025-12-08T23:21:04.664Z",
"level": "INFO",
"requestId": "405a4537-9226-4216-ac59-64381ec8654a",
"message": "Some object - { data: 12.3, flag: false }"
}
```
Lambda weist Ausgaben, die mit `console.log` generiert wurden, der Protokollebene INFO zu.
Das letzte Beispiel zeigt, wie Fehlerobjekte mithilfe der Methoden in CloudWatch Logs ausgegeben werden können. `console` Beachten Sie, dass Lambda die Felder `errorMessage`, `errorType` und `stackTrace` zur Protokollausgabe hinzufügt, wenn Sie Fehlerobjekte mit mehreren Argumenten protokollieren.
**Example Protokollcode für Node.js**
```
export const handler = async (event) => {
let e1 = new ReferenceError("some reference error");
let e2 = new SyntaxError("some syntax error");
console.log(e1);
console.log("errors logged - ", e1, e2);
};
```
**Example JSON-Protokolldatensatz**
```
{
"timestamp": "2025-12-08T23:21:04.632Z",
"level": "INFO",
"requestId": "405a4537-9226-4216-ac59-64381ec8654a",
"message": {
"errorType": "ReferenceError",
"errorMessage": "some reference error",
"stackTrace": [
"ReferenceError: some reference error",
" at Runtime.handler (file:///var/task/index.mjs:3:12)",
" at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
]
}
}
{
"timestamp": "2025-12-08T23:21:04.646Z",
"level": "INFO",
"requestId": "405a4537-9226-4216-ac59-64381ec8654a",
"message": "errors logged - ReferenceError: some reference error\n at Runtime.handler (file:///var/task/index.mjs:3:12)\n at Runtime.handleOnceNonStreaming
(file:///var/runtime/index.mjs:1173:29) SyntaxError: some syntax error\n at Runtime.handler (file:///var/task/index.mjs:4:12)\n at Runtime.handleOnceNonStreaming
(file:///var/runtime/index.mjs:1173:29)",
"errorType": "ReferenceError",
"errorMessage": "some reference error",
"stackTrace": [
"ReferenceError: some reference error",
" at Runtime.handler (file:///var/task/index.mjs:3:12)",
" at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
]
}
```
Bei der Protokollierung mehrerer Fehlertypen werden die zusätzlichen Felder `errorMessage`, `errorType` und `stackTrace` aus dem ersten Fehlertyp extrahiert, der an die `console`-Methode übergeben wurde.
### Verwenden von Clientbibliotheken im Embedded Metric Format (EMF) mit strukturierten JSON-Protokollen
AWS stellt Open-Source-Clientbibliotheken für Node.js bereit, mit denen Sie Logs im [Embedded Metric Format](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html) (EMF) erstellen können. Wenn Sie bereits über Funktionen verfügen, die diese Bibliotheken verwenden, und Sie das Protokollformat Ihrer Funktion in JSON ändern, werden die von Ihrem Code ausgegebenen Metriken CloudWatch möglicherweise nicht mehr erkannt.
Wenn Ihr Code derzeit EMF-Protokolle direkt mit `console.log` oder mithilfe von Powertools for AWS Lambda (TypeScript) ausgibt, können CloudWatch Sie diese auch nicht analysieren, wenn Sie das Protokollformat Ihrer Funktion in JSON ändern.
**Wichtig**
[Um sicherzustellen, dass die EMF-Protokolle Ihrer Funktionen weiterhin ordnungsgemäß analysiert werden, aktualisieren Sie Ihre EMF- und Powertools for CloudWatch -Bibliotheken auf die neuesten [Versionen](https://www.npmjs.com/package/aws-embedded-metrics). AWS Lambda](https://github.com/aws-powertools/powertools-lambda-typescript) Wenn Sie zum JSON-Protokollformat wechseln, empfehlen wir Ihnen zudem, Tests durchzuführen, um die Kompatibilität mit den eingebetteten Metriken Ihrer Funktion sicherzustellen. Wenn Ihr Code EMF-Protokolle direkt mit `console.log` ausgibt, ändern Sie Ihren Code so, dass diese Metriken direkt in `stdout` ausgegeben werden, wie im folgenden Codebeispiel gezeigt.
**Example Code, der eingebettete Metriken in `stdout` ausgibt**
```
process.stdout.write(JSON.stringify(
{
"_aws": {
"Timestamp": Date.now(),
"CloudWatchMetrics": [{
"Namespace": "lambda-function-metrics",
"Dimensions": [["functionVersion"]],
"Metrics": [{
"Name": "time",
"Unit": "Milliseconds",
"StorageResolution": 60
}]
}]
},
"functionVersion": "$LATEST",
"time": 100,
"requestId": context.awsRequestId
}
) + "\n")
```
### Verwenden der Filterung auf Protokollebene mit Node.js
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 den Standardmethoden der Konsole und konfigurieren Sie Ihre Funktion so, dass sie die JSON-Protokollformatierung verwendet. AWS Lambda filtert dann Ihre Protokollausgaben anhand des Schlüsselwertpaars „Level“ im JSON-Objekt, wie unter beschrieben[Verwenden strukturierter JSON-Protokolle mit Node.js](#nodejs-logging-advanced-JSON). 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 zum Beispiel verwenden, AWS Lambda um strukturierte JSON-Protokollausgaben aus Ihrem Code zu generieren. Weitere Informationen zur Verwendung von Powertools mit der Laufzeit Node.js finden Sie unter [TypeScript Lambda-Funktionen protokollieren und überwachen](typescript-logging.md).
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.
Wenn Sie Ihre Funktion für die Filterung auf Protokollebene konfigurieren, wählen Sie aus den folgenden Optionen die Ebene der CloudWatch Protokolle aus AWS Lambda , die Sie an Logs senden möchten:
| Protokollebene | Standardnutzung |
| --- | --- |
| TRACE (am detailliertesten) | Die detailliertesten Informationen, die verwendet werden, um den Ausführungspfad Ihres Codes nachzuverfolgen |
| DEBUG | Detaillierte Informationen für das System-Debugging |
| INFO | Meldungen, die den normalen Betrieb Ihrer Funktion erfassen |
| WARN | Meldungen über mögliche Fehler, die zu unerwartetem Verhalten führen können, wenn sie nicht behoben werden |
| ERROR | Meldungen über Probleme, die verhindern, dass der Code wie erwartet funktioniert |
| FATAL (am wenigsten Details) | Meldungen über schwerwiegende Fehler, die dazu führen, dass die Anwendung nicht mehr funktioniert |
Lambda sendet Protokolle der ausgewählten Stufe und niedriger bis CloudWatch. Wenn Sie beispielsweise die Protokollebene WARN konfigurieren, sendet Lambda Protokolle, die den Stufen WARN, ERROR und FATAL entsprechen.
## 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**.
## Protokolle in der Konsole anzeigen CloudWatch
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 Logs 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 mit dem Befehl () anzeigen AWS Command Line Interface 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.
# Instrumentierung von Node.js 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 zwei 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 Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html) – Ein SDK zum Generieren und Senden von Nachverfolgungsdaten an X-Ray.
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**
+ [
## Verwenden von ADOT zur Instrumentierung Ihrer Node.js-Funktionen
](#nodejs-adot)
+ [
## Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Node.js-Funktionen
](#nodejs-xray-sdk)
+ [
## Aktivieren der Nachverfolgung mit der Lambda-Konsole
](#nodejs-tracing-console)
+ [
## Aktivieren der Nachverfolgung mit der Lambda-API
](#nodejs-tracing-api)
+ [
## Die Ablaufverfolgung wird aktiviert mit CloudFormation
](#nodejs-tracing-cloudformation)
+ [
## Interpretieren einer X-Ray-Nachverfolgung
](#nodejs-tracing-interpretation)
+ [
## Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)
](#nodejs-tracing-layers)
## Verwenden von ADOT zur Instrumentierung Ihrer Node.js-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 Node.js-Laufzeiten können Sie den **AWS -verwalteten Lambda-Ebene für ADOT Javascript** hinzufügen, um Ihre Funktionen automatisch zu instrumentieren. Eine ausführliche Anleitung zum Hinzufügen dieser Ebene finden Sie unter [AWS Distro for OpenTelemetry Lambda Support for JavaScript](https://aws-otel.github.io/docs/getting-started/lambda/lambda-js) in der ADOT-Dokumentation.
## Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Node.js-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 Node.js verwenden. Um das SDK zu erhalten, fügen Sie das `aws-xray-sdk-core`-Paket den Abhängigkeiten Ihrer Anwendung hinzu.
**Example [blank-nodejs/package.json](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/package.json)**
```
{
"name": "blank-nodejs",
"version": "1.0.0",
"private": true,
"devDependencies": {
"jest": "29.7.0"
},
"dependencies": {
"@aws-sdk/client-lambda": "3.345.0",
"aws-xray-sdk-core": "3.5.3"
},
"scripts": {
"test": "jest"
}
}
```
Um AWS SDK-Clients in Version 3 zu instrumentieren [AWS SDK für JavaScript ,](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html) schließen Sie die Client-Instanz mit der Methode ein. `captureAWSv3Client`
**Example [blank- nodejs/function/index .js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/function/index.js) — Einen AWS SDK-Client verfolgen**
```
const AWSXRay = require('aws-xray-sdk-core');
const { LambdaClient, GetAccountSettingsCommand } = require('@aws-sdk/client-lambda');
// Create client outside of handler to reuse
const lambda = AWSXRay.captureAWSv3Client(new LambdaClient());
// Handler
exports.handler = async function(event, context) {
event.Records.forEach(record => {
...
```
Die Lambda-Laufzeit legt zur Konfiguration des X-Ray-SDK einige Umgebungsvariablen fest. Beispielsweise setzt Lambda `AWS_XRAY_CONTEXT_MISSING` auf `LOG_ERROR`, um Laufzeitfehler aus dem X-Ray-SDK zu vermeiden. Um eine benutzerdefinierte Strategie für fehlenden Kontext festzulegen, überschreiben Sie die Umgebungsvariable in der Funktionskonfiguration so, dass sie keinen Wert aufweist. Dann können Sie die Strategie für fehlenden Kontext programmgesteuert festlegen.
**Example Beispiel-Initialisierungscode**
```
const AWSXRay = require('aws-xray-sdk-core');
// Configure the context missing strategy to do nothing
AWSXRay.setContextMissingStrategy(() => {});
```
Weitere Informationen finden Sie unter [Arbeiten mit Lambda-Umgebungsvariablen](configuration-envvars.md).
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 Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.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 Node.js speichert.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/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-nodejs-lib
Description: Dependencies for the blank sample app.
ContentUri: lib/.
CompatibleRuntimes:
- nodejs24.x
```
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-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs) .