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.
# Aufbau von Lambda-Funktionen mit TypeScript
Sie können die Laufzeit von Node.js verwenden, um TypeScript Code darin AWS Lambda auszuführen. Da Node.js TypeScript Code nicht nativ ausführt, müssen Sie Ihren TypeScript Code zuerst in das Format transpilieren. JavaScript Verwenden Sie dann die JavaScript Dateien, um Ihren Funktionscode für Lambda bereitzustellen. Ihr Code wird in einer Umgebung ausgeführt, die das AWS SDK für enthält JavaScript, mit Anmeldeinformationen aus einer AWS Identity and Access Management (IAM-) Rolle, 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](lambda-nodejs.md#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 |
**Topics**
+ [
## Einrichtung einer TypeScript Entwicklungsumgebung
](#typescript-dev)
+ [
## Typdefinitionen für Lambda
](#typescript-type-definitions)
+ [
# Definieren Sie den Lambda-Funktionshandler in TypeScript
](typescript-handler.md)
+ [
# Stellen Sie transpilierten TypeScript Code in Lambda mit ZIP-Dateiarchiven bereit
](typescript-package.md)
+ [
# Stellen Sie transpilierten TypeScript Code in Lambda mit Container-Images bereit
](typescript-image.md)
+ [
# Verwenden des Lambda-Kontextobjekts zum Abrufen von TypeScript Funktionsinformationen
](typescript-context.md)
+ [
# TypeScript Lambda-Funktionen protokollieren und überwachen
](typescript-logging.md)
+ [
# TypeScript Code nachverfolgen in AWS Lambda
](typescript-tracing.md)
## Einrichtung einer TypeScript Entwicklungsumgebung
Verwenden Sie eine lokale integrierte Entwicklungsumgebung (IDE) oder einen Texteditor, um Ihren TypeScript Funktionscode zu schreiben. Sie können auf der Lambda-Konsole keinen TypeScript Code erstellen.
Sie können entweder [esbuild](https://esbuild.github.io/) oder den TypeScript Compiler (`tsc`) von Microsoft verwenden, um Ihren Code in zu transpilieren. TypeScript JavaScript [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) und [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) verwenden beide „esbuild“.
Wenn Sie esbuild verwenden, beachten Sie Folgendes:
+ [Es gibt mehrere Vorbehalte. TypeScript ](https://esbuild.github.io/content-types/#typescript-caveats)
+ Sie müssen Ihre TypeScript Transpilationseinstellungen so konfigurieren, dass sie der Laufzeit von Node.js entsprechen, die Sie verwenden möchten. Weitere Informationen finden Sie unter [Ziel](https://esbuild.github.io/api/#target) in der esbuild-Dokumentation. [Ein Beispiel für eine **tsconfig.json-Datei**, die zeigt, wie Sie auf eine bestimmte, von Lambda unterstützte Version von Node.js abzielen, finden Sie im Repository. TypeScript GitHub ](https://github.com/tsconfig/bases/blob/main/bases/node14.json)
+ esbuild führt keine Typ-Überprüfungen durch. Um Typen zu überprüfen, verwenden Sie den `tsc`-Compiler. Führen Sie `tsc -noEmit` aus oder fügen Sie einen `"noEmit"`-Parameter zu Ihrer **tsconfig.json**-Datei hinzu, wie im folgenden Beispiel gezeigt. Dies ist so konfiguriert`tsc`, dass keine Dateien ausgegeben werden. JavaScript Verwenden Sie nach der Überprüfung der Typen Esbuild, um die TypeScript Dateien in zu konvertieren. JavaScript
**Example tsconfig.json**
```
{
"compilerOptions": {
"target": "es2020",
"strict": true,
"preserveConstEnums": true,
"noEmit": true,
"sourceMap": false,
"module":"commonjs",
"moduleResolution":"node",
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"isolatedModules": true,
},
"exclude": ["node_modules", "**/*.test.ts"]
}
```
## Typdefinitionen für Lambda
Das Paket [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) enthält Typdefinitionen für Lambda-Funktionen. Installieren Sie dieses Paket, wenn Ihre Funktion eines der folgenden Elemente verwendet:
+ Allgemeine AWS Ereignisquellen, wie zum Beispiel:
+ `APIGatewayProxyEvent`: Für [Für Proxy-Integrationen in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html)
+ `SNSEvent`: Für [Amazon-Simple-Notification-Service-Benachrichtigungen](with-sns.md)
+ `SQSEvent`: Für [Amazon-Simple-Queue-Service-Nachrichten](with-sqs.md)
+ `S3Event`: Für [S3-Auslöserereignisse](with-s3.md)
+ `DynamoDBStreamEvent`: Für [Amazon DynamoDB Streams](with-ddb.md)
+ Das Lambda-[Kontext](typescript-context.md)-Objekt
+ Das [Callback](typescript-handler.md#typescript-handler-callback)-Handler-Muster
Um die Lambda-Typdefinitionen zu Ihrer Funktion hinzuzufügen, installieren Sie `@types/aws-lambda` als eine Entwicklungsabhängigkeit:
```
npm install -D @types/aws-lambda
```
Importieren Sie dann die Typen aus `aws-lambda`:
```
import { Context, S3Event, APIGatewayProxyEvent } from 'aws-lambda';
export const handler = async (event: S3Event, context: Context) => {
// Function code
};
```
Die `import ... from 'aws-lambda'`-Anweisung importiert die Typdefinitionen. Das `aws-lambda`-NPM-Paket wird nicht importiert, da es sich um ein unabhängiges Tool eines Drittanbieters handelt. Weitere Informationen finden Sie unter [aws-lambda im Repository](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda). DefinitelyTyped GitHub
**Anmerkung**
Sie benötigen [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) nicht, wenn Sie Ihre eigenen benutzerdefinierten Typdefinitionen verwenden. Eine Beispielfunktion, die ihren eigenen Typ für ein Ereignisobjekt definiert, finden Sie unter [Beispiel für einen TypeScript Lambda-Funktionscode](typescript-handler.md#typescript-example-code).
# Definieren Sie den Lambda-Funktionshandler in TypeScript
Der Lambda-Funktions*handler* ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt.
Auf dieser Seite wird beschrieben, wie Sie mit Lambda-Funktionshandlern arbeiten TypeScript, einschließlich Optionen für die Projekteinrichtung, Benennungskonventionen und Best Practices. Diese Seite enthält auch ein Beispiel für eine TypeScript Lambda-Funktion, die Informationen über eine Bestellung aufnimmt, eine Textdateiquittung erstellt und diese Datei in einem Amazon Simple Storage Service (Amazon S3) -Bucket ablegt. Informationen darüber, wie Sie Ihre Funktion nach dem Schreiben einsetzen können, finden Sie unter [Stellen Sie transpilierten TypeScript Code in Lambda mit ZIP-Dateiarchiven bereit](typescript-package.md) oder [Stellen Sie transpilierten TypeScript Code in Lambda mit Container-Images bereit](typescript-image.md).
**Topics**
+ [
## Ihr TypeScript Projekt einrichten
](#typescript-handler-setup)
+ [
## Beispiel für einen TypeScript Lambda-Funktionscode
](#typescript-example-code)
+ [
## CommonJS- und ES-Module
](#typescript-commonjs-es-modules)
+ [
## Initialisierung von Node.js
](#typescript-initialization)
+ [
## Namenskonventionen für Handler
](#typescript-handler-naming)
+ [
## Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu
](#typescript-example-input)
+ [
## Gültige Handlermuster für Funktionen TypeScript
](#typescript-handler-signatures)
+ [
## Verwenden Sie das SDK für JavaScript v3 in Ihrem Handler
](#typescript-example-sdk-usage)
+ [
## Zugriff auf Umgebungsvariablen
](#typescript-example-envvars)
+ [
## Verwenden des globalen Zustands
](#typescript-handler-state)
+ [
## Bewährte Codepraktiken für TypeScript Lambda-Funktionen
](#typescript-best-practices)
## Ihr TypeScript Projekt einrichten
Verwenden Sie eine lokale integrierte Entwicklungsumgebung (IDE) oder einen Texteditor, um Ihren TypeScript Funktionscode zu schreiben. Sie können auf der Lambda-Konsole keinen TypeScript Code erstellen.
Es gibt mehrere Möglichkeiten, ein TypeScript Lambda-Projekt zu initialisieren. Sie können beispielsweise ein Projekt mit `npm` erstellen oder eine [AWS SAM -](typescript-package.md#aws-sam-ts) bzw. [AWS CDK -Anwendung](typescript-package.md#aws-cdk-ts) erstellen. So erstellen Sie das Projekt mit `npm`:
```
npm init
```
Ihr Funktionscode befindet sich in einer `.ts` Datei, die Sie bei der Erstellung in eine JavaScript Datei transpilieren. Sie können entweder [esbuild](https://esbuild.github.io/) oder den TypeScript Compiler (`tsc`) von Microsoft verwenden, um Ihren Code in diese Datei zu transpilieren. TypeScript JavaScript Um „esbuild“ zu verwenden, fügen Sie es als Entwicklungsabhängigkeit hinzu:
```
npm install -D esbuild
```
Ein typisches TypeScript Lambda-Funktionsprojekt folgt dieser allgemeinen Struktur:
```
/project-root
├── index.ts - Contains main handler
├── dist/ - Contains compiled JavaScript
├── package.json - Project metadata and dependencies
├── package-lock.json - Dependency lock file
├── tsconfig.json - TypeScript configuration
└── node_modules/ - Installed dependencies
```
## Beispiel für einen TypeScript 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. Dieses Beispiel definiert einen benutzerdefinierten Ereignistyp (`OrderEvent`). Informationen zum Importieren von Typdefinitionen für AWS Ereignisquellen finden Sie unter [Typdefinitionen für Lambda](lambda-typescript.md#typescript-type-definitions).
**Anmerkung**
In diesem Beispiel wird ein ES-Modul-Handler verwendet. Lambda unterstützt sowohl ES-Modul- als auch CommonJS-Handler. Weitere Informationen finden Sie unter [CommonJS- und ES-Module](nodejs-handler.md#nodejs-commonjs-es-modules).
**Example Lambda-Funktion „index.ts“**
```
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
// Initialize the S3 client outside the handler for reuse
const s3Client = new S3Client();
// Define the shape of the input event
type OrderEvent = {
order_id: string;
amount: number;
item: string;
}
/**
* Lambda handler for processing orders and storing receipts in S3.
*/
export const handler = async (event: OrderEvent): Promise => {
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 instanceof Error ? error.message : 'Unknown error'}`);
throw error;
}
};
/**
* Helper function to upload receipt to S3
*/
async function uploadReceiptToS3(bucketName: string, key: string, receiptContent: string): Promise {
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 instanceof Error ? error.message : 'Unknown error'}`);
}
}
```
Diese `index.ts`-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.
+ `type OrderEvent`: Definiert die Struktur des erwarteten Eingabeereignisses.
+ `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](#typescript-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.
## 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 arbeiten TypeScript, können Sie die Form des Eingabeereignisses mithilfe eines Typs oder einer Schnittstelle definieren. In diesem Beispiel definieren wir die Ereignisstruktur mithilfe eines Typs:
```
type OrderEvent = {
order_id: string;
amount: number;
item: string;
}
```
Nachdem Sie den Typ oder die Schnittstelle definiert haben, verwenden Sie ihn bzw. sie in der Signatur Ihres Handlers, um die Typsicherheit zu gewährleisten:
```
export const handler = async (event: OrderEvent): Promise => {
```
TypeScript Überprüft während der Kompilierung, ob das Ereignisobjekt die erforderlichen Felder mit den richtigen Typen enthält. Der TypeScript Compiler meldet beispielsweise einen Fehler, wenn Sie versuchen, eine Zahl oder `event.amount` eine Zeichenfolge zu verwenden`event.order_id`.
## Gültige Handlermuster für Funktionen TypeScript
[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.
Für die Beispiele in diesem Abschnitt wird der Typ `S3Event` verwendet. Sie können jedoch alle anderen AWS Ereignistypen im Paket [@types /aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) verwenden oder Ihren eigenen Ereignistyp definieren. Verwenden von Typen aus @types/aws-lambda:
1. Fügen Sie das Paket @types/aws-lambda als Entwicklungsabhängigkeit hinzu:
```
npm install -D @types/aws-lambda
```
1. Importieren Sie die Typen, die Sie benötigen, wie `Context`, `S3Event` oder `Callback`.
### asynchrone Funktionshandler (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 TypeScript Funktionsinformationen](typescript-context.md).
Hier sind die gültigen Signaturen für das async/await Muster:
```
export const handler = async (event: S3Event): Promise => { };
```
```
export const handler = async (event: S3Event, context: Context): Promise => { };
```
**Anmerkung**
Bei der asynchronen Verarbeitung von Arrays von Elementen sollten Sie „Await“ mit `Promise.all` verwenden, um sicherzustellen, dass alle Vorgänge abgeschlossen werden. Methoden wie `forEach` warten nicht darauf, dass asynchrone Callbacks abgeschlossen werden. Weitere Informationen finden Sie unter [Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) in der Mozilla-Dokumentation.
### 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: S3Event): void => { };
```
```
export const handler = (event: S3Event, context: Context): void => { };
```
### Handler für Antwort-Streaming-Funktionen
Lambda unterstützt Response-Streaming mit Node.js. Handler für Antwort-Streaming-Funktionen verwenden den Dekorator AWSLambda.streamifyResponse () und verwenden drei Parameter: event, responseStream und context. Die Funktionssignatur lautet:
```
export const handler = awslambda.streamifyResponse(async (event: APIGatewayProxyEvent, responseStream: NodeJS.WritableStream, context: Context) => { });
```
Weitere Informationen finden Sie unter Antwortstreaming für Lambda-Funktionen.
### 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 können die Event-, Kontext- und Callback-Argumente verwenden. Das Callback-Argument erwartet `Error` und eine Antwort, die JSON-serialisierbar sein muss.
Hier ist die gültige Signatur für das Callback-Handler-Muster:
```
export const handler = (event: S3Event, context: Context, callback: Callback): void => { };
```
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](typescript-context.md)auf „Falsch“ setzen.
**Example TypeScript Funktion mit Rückruf**
Das folgende Beispiel verwendet `APIGatewayProxyCallback`, einen Callback-Typ, der speziell für API-Gateway-Integrationen gilt. Die meisten AWS Ereignisquellen verwenden den generischen `Callback` Typ, der in den obigen Signaturen gezeigt wird.
```
import { Context, APIGatewayProxyCallback, APIGatewayEvent } from 'aws-lambda';
export const lambdaHandler = (event: APIGatewayEvent, context: Context, callback: APIGatewayProxyCallback): void => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
callback(null, {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
});
};
```
## 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 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.
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 AWS Dienst zu tätigen. 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 Codepraktiken für TypeScript 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/).
# Stellen Sie transpilierten TypeScript Code in Lambda mit ZIP-Dateiarchiven bereit
Bevor Sie TypeScript Code bereitstellen können AWS Lambda, müssen Sie ihn transpilieren in. JavaScript Auf dieser Seite werden drei Möglichkeiten zum Erstellen und Bereitstellen von TypeScript Code für Lambda mit ZIP-Dateiarchiven beschrieben:
+ [Verwenden von AWS Serverless Application Model ()AWS SAM](#aws-sam-ts)
+ [Mit dem AWS Cloud Development Kit (AWS CDK)](#aws-cdk-ts)
+ [Verwenden von AWS Command Line Interface (AWS CLI) und esbuild](#aws-cli-ts)
AWS SAM und AWS CDK vereinfachen das Erstellen und Bereitstellen von TypeScript Funktionen. Die [AWS SAM Vorlagenspezifikation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) bietet eine einfache und übersichtliche Syntax zur Beschreibung der Lambda-Funktionen APIs, Berechtigungen, Konfigurationen und Ereignisse, aus denen Ihre serverlose Anwendung besteht. Über das [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html) Sie können zuverlässige, skalierbare und kostengünstige Anwendungen in der Cloud mit der beträchtlichen Ausdruckskraft einer Programmiersprache erstellen. Das AWS CDK richtet sich an mäßig bis sehr erfahrene Benutzer. AWS AWS CDK Sowohl der als auch der AWS SAM verwenden Esbuild, um Code zu transpilieren TypeScript . JavaScript
## Verwenden AWS SAM , um TypeScript Code für Lambda bereitzustellen
Gehen Sie wie folgt vor, um eine Hello TypeScript World-Beispielanwendung herunterzuladen, zu erstellen und bereitzustellen AWS SAM. Diese Anwendung implementiert ein grundlegendes API-Backend. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anforderung an den API-Gateway-Endpunkt senden, wird die Lambda-Funktion aufgerufen. Die Funktion gibt eine `hello world`-Nachricht zurück.
**Anmerkung**
AWS SAM verwendet esbuild, um Lambda-Funktionen von Node.js aus TypeScript Code zu erstellen. Die Esbuild-Unterstützung befindet sich derzeit in der öffentlichen Vorschauversion. Während der öffentlichen Vorschau kann der esbuild-Support Änderungen unterliegen, die nicht mehr rückwärtskompatibel sind.
**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)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
+ Node.js
**Stellen Sie eine Beispielanwendung AWS SAM bereit**
1. Initialisieren Sie die Anwendung mithilfe der Hello TypeScript World-Vorlage.
```
sam init --app-template hello-world-typescript --name sam-app --package-type Zip --runtime nodejs24.x
```
1. (Optional) Die Beispielanwendung enthält Konfigurationen für häufig verwendete Tools, z. B. [ESLlint](https://eslint.org/)für Code-Linting und [Jest](https://jestjs.io/) für Komponententests. So führen Sie Lint- und Testbefehle aus:
```
cd sam-app/hello-world
npm install
npm run lint
npm run test
```
1. Entwickeln Sie die App.
```
cd sam-app
sam build
```
1. Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, antworten Sie mit `Enter`.
1. Die Ausgabe zeigt den Endpunkt für die REST-API. Öffnen Sie den Endpunkt in einem Browser, um die Funktion zu testen. Folgende Antwort sollte angezeigt werden:
```
{"message":"hello world"}
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
## Verwenden von AWS CDK , um TypeScript Code für Lambda bereitzustellen
Gehen Sie wie folgt vor, um eine TypeScript Beispielanwendung mit dem zu erstellen und bereitzustellen AWS CDK. Diese Anwendung implementiert ein grundlegendes API-Backend. Es besteht aus einem API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anforderung an den API-Gateway-Endpunkt senden, wird die Lambda-Funktion aufgerufen. Die Funktion gibt eine `hello world`-Nachricht zurück.
**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)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ Node.js
+ Entweder [Docker](https://www.docker.com/get-started/) oder [esbuild](https://esbuild.github.io/)
**Stellen Sie eine AWS CDK Beispielanwendung bereit**
1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
1. Initialisieren Sie die App.
```
cdk init app --language typescript
```
1. Fügen Sie das [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda)-Paket als Entwicklungsabhängigkeit hinzu. Dieses Paket enthält die Typdefinitionen für Lambda.
```
npm install -D @types/aws-lambda
```
1. Öffnen Sie das **lib**-Verzeichnis. Sie sollten eine Datei mit dem Namen „**hello-world-stack.ts**“ sehen. Erstellen Sie neue zwei neue Dateien in diesem Verzeichnis: **hello-world.function.ts** und **hello-world.ts**.
1. Öffnen Sie **hello-world.function.ts** und fügen Sie den folgenden Code in die Datei ein. Dies ist der Code für die Lambda-Funktion.
**Anmerkung**
Die `import`-Anweisung importiert die Typdefinitionen aus [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Das `aws-lambda`-NPM-Paket wird nicht importiert, da es sich um ein unabhängiges Tool eines Drittanbieters handelt. Weitere Informationen finden Sie unter [aws-lambda](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda) im Repository. DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Öffnen Sie **hello-world.ts** und fügen Sie den folgenden Code in die Datei ein. Dies enthält das [NodejsFunction Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html), das die Lambda-Funktion erstellt, und das [LambdaRestApi Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html), das die REST-API erstellt.
```
import { Construct } from 'constructs';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import { LambdaRestApi } from 'aws-cdk-lib/aws-apigateway';
export class HelloWorld extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
const helloFunction = new NodejsFunction(this, 'function');
new LambdaRestApi(this, 'apigw', {
handler: helloFunction,
});
}
}
```
Das `NodejsFunction`-Konstrukt geht standardmäßig von folgendem aus:
+ Ihr Funktions-Handler heißt `handler`.
+ Die .ts-Datei, die den Funktionscode enthält (**hello-world.function.ts**), befindet sich im selben Verzeichnis wie die .ts-Datei, die das Konstrukt (**hello-world.ts**) enthält. Das Konstrukt verwendet die ID des Konstrukts („hello-world“) und den Namen der Lambda-Handler-Datei („function“), um den Funktionscode zu finden. Wenn sich Ihr Funktionscode beispielsweise in einer Datei namens **hello-world.my-function.ts** befindet, muss die Datei **hello-world.ts** wie folgt auf den Funktionscode verweisen:
```
const helloFunction = new NodejsFunction(this, 'my-function');
```
Sie können dieses Verhalten ändern und andere esbuild-Parameter konfigurieren. Weitere Informationen finden Sie unter [Konfiguration von esbuild](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html#configuring-esbuild) in der AWS CDK API-Referenz.
1. Öffnen Sie **hello-world-stack.ts.** Dies ist der Code, der Ihren [AWS CDK -Stack](https://docs.aws.amazon.com/cdk/v2/guide/stacks.html) definiert. Ersetzen Sie den Code mit Folgendem:
```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { HelloWorld } from './hello-world';
export class HelloWorldStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new HelloWorld(this, 'hello-world');
}
}
```
1. Stellen Sie Ihre Anwendung aus dem Verzeichnis `hello-world` bereit, das Ihre `cdk.json` Datei enthält.
```
cdk deploy
```
1. Der AWS CDK erstellt und verpackt die Lambda-Funktion mithilfe von esbuild und stellt die Funktion dann für die Lambda-Laufzeit bereit. Die Ausgabe zeigt den Endpunkt für die REST-API. Öffnen Sie den Endpunkt in einem Browser, um die Funktion zu testen. Folgende Antwort sollte angezeigt werden:
```
{"message":"hello world"}
```
Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
## Verwenden von AWS CLI und esbuild zum Bereitstellen von TypeScript Code für Lambda
Das folgende Beispiel zeigt, wie TypeScript Code mithilfe von esbuild transpiliert und für Lambda bereitgestellt wird AWS CLI. esbuild erzeugt eine JavaScript Datei mit allen Abhängigkeiten. Dies ist die einzige Datei, die Sie dem ZIP-Archiv hinzufügen müssen.
**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)
+ Node.js
+ Eine [Ausführungsrolle](lambda-intro-execution-role.md) für die Lambda-Funktion
+ Für Windows-Benutzer ein ZIP-Datei-Hilfsprogramm wie [7zip](https://www.7-zip.org/download.html).
**Bereitstellen einer Beispielfunktion**
1. Erstellen Sie auf Ihrem lokalen Computer ein Projektverzeichnis für Ihre neue Funktion.
1. Erstellen Sie ein neues Node.js Projekt mit npm oder einem Paketmanager Ihrer Wahl.
```
npm init
```
1. Fügen Sie die Pakete [@types /aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) und [esbuild](https://esbuild.github.io/) als Entwicklungsabhängigkeiten hinzu. Das `@types/aws-lambda`-Paket enthält die Typdefinitionen für Lambda.
```
npm install -D @types/aws-lambda esbuild
```
1. Erstellen Sie eine neue Datei mit dem Namen **index.ts**. Fügen Sie den folgenden Code zur Datei hinzu. Dies ist der Code für die Lambda-Funktion. Die Funktion gibt eine `hello world`-Nachricht zurück. Die Funktion erstellt keine API-Gateway-Ressourcen.
**Anmerkung**
Die `import`-Anweisung importiert die Typdefinitionen aus [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Das `aws-lambda`-NPM-Paket wird nicht importiert, da es sich um ein unabhängiges Tool eines Drittanbieters handelt. Weitere Informationen finden Sie unter [aws-lambda im Repository](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda). DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Hinzufügen eines Entwicklungs-Skripts zur **package.json**-Datei. Dies konfiguriert esbuild so, dass das ZIP-Bereitstellungspaket automatisch erstellt wird. Weitere Informationen finden Sie unter [Entwicklungs-Skripte](https://esbuild.github.io/getting-started/#build-scripts) in der esbuild-Dokumentation.
------
#### [ Linux and MacOS ]
```
"scripts": {
"prebuild": "rm -rf dist",
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js",
"postbuild": "cd dist && zip -r index.zip index.js*"
},
```
------
#### [ Windows ]
In diesem Beispiel verwendet der `"postbuild"` Befehl das [7zip](https://www.7-zip.org/download.html)-Hilfsprogramm, um Ihre ZIP-Datei zu erstellen. Verwenden Sie Ihr bevorzugtes Windows-ZIP-Hilfsprogramm und ändern Sie den Befehl nach Bedarf.
```
"scripts": {
"prebuild": "del /q dist",
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js",
"postbuild": "cd dist && 7z a -tzip index.zip index.js*"
},
```
------
1. Erstellen Sie das Paket.
```
npm run build
```
1. Erstellen Sie eine Lambda-Funktion mit dem ZIP-Bereitstellungspaket. Ersetzen Sie den markierten Text durch den Amazon-Ressourcennamen (ARN) Ihrer [Ausführungsrolle](lambda-intro-execution-role.md).
```
aws lambda create-function --function-name hello-world --runtime "nodejs24.x" --role arn:aws:iam::123456789012:role/lambda-ex --zip-file "fileb://dist/index.zip" --handler index.handler
```
1. [Führen Sie ein Testereignis aus](testing-functions.md), um zu bestätigen, dass die Funktion die folgende Antwort zurückgibt. Wenn Sie diese Funktion mit API Gateway aufrufen möchten, [Erstellen und Konfigurieren Sie eine REST-API](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html).
```
{
"statusCode": 200,
"body": "{\"message\":\"hello world\"}"
}
```
# Stellen Sie transpilierten TypeScript Code in Lambda mit Container-Images bereit
Sie können Ihren TypeScript Code als [Container-Image](images-create.md) für Node.js in einer AWS Lambda Funktion bereitstellen. AWS stellt [Basis-Images](nodejs-image.md#nodejs-image-base) für Node.js bereit, um Ihnen bei der Erstellung des Container-Images zu helfen. Diese Basis-Images sind mit einer Sprachlaufzeit und anderen Komponenten, die für die Ausführung des Images auf Lambda erforderlich sind, vorinstalliert. AWS stellt für jedes der Basis-Images ein Dockerfile bereit, das Sie beim Erstellen Ihres Container-Images unterstützt.
Wenn Sie ein Community- oder Privatunternehmens-Basis-Image verwenden, müssen Sie den [Node.js-Laufzeitschnittstellen-Client (RIC)](nodejs-image.md#nodejs-image-clients) zum Basis-Image hinzufügen, um es mit Lambda kompatibel zu machen.
Lambda bietet einen Emulator für die Laufzeitschnittstelle zum lokalen Testen. Die AWS Basis-Images für Node.js enthalten den Runtime-Interface-Emulator. Wenn Sie ein alternatives Basis-Image verwenden (beispielsweise ein Alpine Linux-Image oder ein Debian-Image), können Sie [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 auf Ihrem lokalen Computer installieren](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#test-an-image-without-adding-rie-to-the-image).
## Verwenden eines Node.js -Basisimages zum Erstellen und Verpacken von TypeScript Funktionscode
### 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 22.x
### Erstellen eines Images aus einem Base Image
**Um ein Image aus einem AWS Basis-Image für Lambda zu erstellen**
1. Erstellen Sie auf Ihrem lokalen Computer ein Projektverzeichnis für Ihre neue Funktion.
1. Erstellen Sie ein neues Node.js-Projekt mit `npm` oder einem Paketmanager Ihrer Wahl.
```
npm init
```
1. Fügen Sie die Pakete [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) und [esbuild](https://esbuild.github.io/) als Entwicklungsabhängigkeiten hinzu. Das `@types/aws-lambda`-Paket enthält die Typdefinitionen für Lambda.
```
npm install -D @types/aws-lambda esbuild
```
1. Hinzufügen eines [Entwicklungs-Skripts](https://esbuild.github.io/getting-started/#build-scripts) zur `package.json`-Datei.
```
"scripts": {
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js"
}
```
1. Erstellen Sie eine neue Datei mit dem Namen `index.ts`. Fügen Sie den folgenden Beispiel-Code zur neuen Datei hinzu. Dies ist der Code für die Lambda-Funktion. Die Funktion gibt eine `hello world`-Nachricht zurück.
**Anmerkung**
Die `import`-Anweisung importiert die Typdefinitionen aus [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Das `aws-lambda`-NPM-Paket wird nicht importiert, da es sich um ein unabhängiges Tool eines Drittanbieters handelt. Weitere Informationen finden Sie unter [aws-lambda](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda) im Repository. DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Erstellen Sie eine neue Docker-Datei mit der folgenden Konfiguration:
+ Setzen Sie die `FROM`-Eigenschaft auf den URI des Basis-Images.
+ Legen Sie das `CMD`-Argument zur Angabe des Lambda-Funktionshandlers fest.
Die folgende Beispiel-Docker-Datei verwendet eine mehrstufige Entwicklung. Der erste Schritt transpiliert den Code in. TypeScript JavaScript Im zweiten Schritt wird ein Container-Image erstellt, das nur JavaScript Dateien und Produktionsabhängigkeiten enthält.
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 as builder
WORKDIR /usr/app
COPY package.json index.ts ./
RUN npm install
RUN npm run build
FROM public.ecr.aws/lambda/nodejs:22
WORKDIR ${LAMBDA_TASK_ROOT}
COPY --from=builder /usr/app/dist/* ./
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 des Lambda-Kontextobjekts zum Abrufen von TypeScript Funktionsinformationen
Wenn Lambda Ihre Funktion ausführt, wird ein Context-Objekt an den [Handler](typescript-handler.md). übergeben. Dieses Objekt stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereit.
Um die Typüberprüfung für das Kontextobjekt zu aktivieren, müssen Sie das Paket [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) als Entwicklungsabhängigkeit hinzufügen und den Typ `Context` importieren. Weitere Informationen finden Sie unter [Typdefinitionen für Lambda](lambda-typescript.md#typescript-type-definitions).
**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.
**Example Datei index.js**
Die folgende Beispielfunktion protokolliert Kontextinformationen und gibt den Speicherort der Protokolle zurück.
Bevor Sie diesen Code in einer Lambda-Funktion verwenden, müssen Sie das Paket [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) als Entwicklungsabhängigkeit hinzufügen. Dieses Paket enthält die Typdefinitionen für Lambda. Weitere Informationen finden Sie unter [Typdefinitionen für Lambda](lambda-typescript.md#typescript-type-definitions).
```
import { Context } from 'aws-lambda';
export const lambdaHandler = async (event: string, context: Context): Promise => {
console.log('Remaining time: ', context.getRemainingTimeInMillis());
console.log('Function name: ', context.functionName);
return context.logStreamName;
};
```
# TypeScript Lambda-Funktionen protokollieren und überwachen
AWS Lambda überwacht automatisch Lambda-Funktionen und sendet Protokolleinträge an Amazon CloudWatch. Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen zu CloudWatch Logs finden Sie unter[Senden von Lambda-Funktionsprotokollen an CloudWatch Logs](monitoring-cloudwatchlogs.md).
Um Protokolle aus Ihrem Funktionscode auszugeben, können Sie Methoden auf dem [Konsolenobjekt](https://nodejs.org/docs/latest-v18.x/api/console.html) verwenden. Für eine detailliertere Protokollierung können Sie jede Protokollierungsbibliothek verwenden, die in `stdout` oder `stderr` schreibt.
**Topics**
+ [
## Tools und Bibliotheken für die Protokollierung verwenden
](#typescript-tools-libraries)
+ [
## Verwendung von Powertools für AWS Lambda (TypeScript) und für die strukturierte Protokollierung AWS SAM
](#typescript-logging-sam)
+ [
## Verwenden Sie Powertools für AWS Lambda (TypeScript) und AWS CDK für die strukturierte Protokollierung
](#typescript-logging-cdk)
+ [
## Anzeigen von Protokollen in der Lambda-Konsole
](#typescript-logging-console)
+ [
## Logs in der CloudWatch Konsole anzeigen
](#typescript-logging-cwconsole)
## Tools und Bibliotheken für die Protokollierung verwenden
[Powertools for AWS Lambda (TypeScript)](https://docs.aws.amazon.com/powertools/typescript/) ist ein Entwickler-Toolkit zur Implementierung von Best Practices für Serverless und zur Steigerung der Entwicklergeschwindigkeit. Das [Logger-Serviceprogramm](https://docs.powertools.aws.dev/lambda/typescript/latest/features/logger/) bietet einen für Lambda optimierten Logger, der zusätzliche Informationen über den Funktionskontext all Ihrer Funktionen enthält, wobei die Ausgabe als JSON strukturiert ist. Mit diesem Serviceprogramm können Sie Folgendes tun:
+ Erfassung von Schlüsselfeldern aus dem Lambda-Kontext, Kaltstart und Strukturen der Protokollierungsausgabe als JSON
+ Protokollieren Sie Ereignisse von Lambda-Aufrufen, wenn Sie dazu aufgefordert werden (standardmäßig deaktiviert)
+ Alle Protokolle nur für einen bestimmten Prozentsatz der Aufrufe über Protokollstichproben drucken (standardmäßig deaktiviert)
+ Fügen Sie dem strukturierten Protokoll zu einem beliebigen Zeitpunkt zusätzliche Schlüssel hinzu
+ Verwenden Sie einen benutzerdefinierten Protokollformatierer (Bring Your Own Formatter), um Protokolle in einer Struktur auszugeben, die mit dem Logging RFC Ihres Unternehmens kompatibel ist
## Verwendung von Powertools für AWS Lambda (TypeScript) und für die strukturierte Protokollierung AWS SAM
Gehen Sie wie folgt vor, um mithilfe von eine Hello TypeScript World-Beispielanwendung mit integrierten [Powertools for AWS Lambda (TypeScript)](https://docs.powertools.aws.dev/lambda-typescript) -Modulen herunterzuladen, zu erstellen und bereitzustellen. AWS SAM Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Node.js 20 oder höher
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS SAM Beispielanwendung bereit**
1. Initialisieren Sie die Anwendung mithilfe der Hello TypeScript World-Vorlage.
```
sam init --app-template hello-world-powertools-typescript --name sam-app --package-type Zip --runtime nodejs24.x
```
1. Entwickeln Sie die App.
```
cd sam-app && sam build
```
1. Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
**Anmerkung**
Für ist **HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung?** , stellen Sie sicher, dass Sie eintreten`y`.
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html) aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter [Arbeiten mit Protokollen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) im *AWS Serverless Application Model -Entwicklerhandbuch*.
```
sam logs --stack-name sam-app
```
Das Ergebnis sieht folgendermaßen aus:
```
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.552000 START RequestId: 70693159-7e94-4102-a2af-98a6343fb8fb Version: $LATEST
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.594000 2025-08-31T09:33:10.557Z 70693159-7e94-4102-a2af-98a6343fb8fb INFO {"_aws":{"Timestamp":1661938390556,"CloudWatchMetrics":[{"Namespace":"sam-app","Dimensions":[["service"]],"Metrics":[{"Name":"ColdStart","Unit":"Count"}]}]},"service":"helloWorld","ColdStart":1}
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.595000 2025-08-31T09:33:10.595Z 70693159-7e94-4102-a2af-98a6343fb8fb INFO {"level":"INFO","message":"This is an INFO log - sending HTTP 200 - hello world response","service":"helloWorld","timestamp":"2025-08-31T09:33:10.594Z"}
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.655000 2025-08-31T09:33:10.655Z 70693159-7e94-4102-a2af-98a6343fb8fb INFO {"_aws":{"Timestamp":1661938390655,"CloudWatchMetrics":[{"Namespace":"sam-app","Dimensions":[["service"]],"Metrics":[]}]},"service":"helloWorld"}
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.754000 END RequestId: 70693159-7e94-4102-a2af-98a6343fb8fb
2025/01/31/[$LATEST]4d53e8d279824834a1ccd35511a4949c 2025-08-31T09:33:10.754000 REPORT RequestId: 70693159-7e94-4102-a2af-98a6343fb8fb Duration: 201.55 ms Billed Duration: 202 ms Memory Size: 128 MB Max Memory Used: 66 MB Init Duration: 252.42 ms
XRAY TraceId: 1-630f2ad5-1de22b6d29a658a466e7ecf5 SegmentId: 567c116658fbf11a Sampled: true
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
### Verwalten der Protokollaufbewahrung
Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um zu vermeiden, dass Protokolle auf unbestimmte Zeit gespeichert werden, löschen Sie die Protokollgruppe oder konfigurieren Sie einen Aufbewahrungszeitraum, nach dessen Ablauf die Protokolle CloudWatch automatisch gelöscht werden. Um die Aufbewahrung von Protokollen einzurichten, fügen Sie Ihrer AWS SAM Vorlage Folgendes hinzu:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
# Omitting other properties
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
RetentionInDays: 7
```
## Verwenden Sie Powertools für AWS Lambda (TypeScript) und AWS CDK für die strukturierte Protokollierung
Gehen Sie wie folgt vor, um mithilfe von eine Hello TypeScript World-Beispielanwendung mit integrierten [Powertools for AWS Lambda (TypeScript)](https://docs.powertools.aws.dev/lambda-typescript) -Modulen herunterzuladen, zu erstellen und bereitzustellen. AWS CDK Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Node.js 20 oder höher
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS CDK Beispielanwendung bereit**
1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
1. Initialisieren Sie die App.
```
cdk init app --language typescript
```
1. Fügen Sie das [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda)-Paket als Entwicklungsabhängigkeit hinzu.
```
npm install -D @types/aws-lambda
```
1. Installieren Sie das [Logger-Dienstprogramm](https://docs.aws.amazon.com/powertools/typescript/latest/features/logger/) von Powertools.
```
npm install @aws-lambda-powertools/logger
```
1. Öffnen Sie das **lib**-Verzeichnis. Sie sollten eine Datei mit dem Namen „**hello-world-stack.ts**“ sehen. Erstellen Sie neue zwei neue Dateien in diesem Verzeichnis: **hello-world.function.ts** und **hello-world.ts**.
1. Öffnen Sie **hello-world.function.ts** und fügen Sie den folgenden Code in die Datei ein. Dies ist der Code für die Lambda-Funktion.
```
import { APIGatewayEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { Logger } from '@aws-lambda-powertools/logger';
const logger = new Logger();
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
logger.info('This is an INFO log - sending HTTP 200 - hello world response');
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Öffnen Sie **hello-world.ts** und fügen Sie den folgenden Code in die Datei ein. Dies enthält das [NodejsFunction Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html), das die Lambda-Funktion erstellt, Umgebungsvariablen für Powertools konfiguriert und die Protokollspeicherung auf eine Woche festlegt. Es beinhaltet auch das [LambdaRestApi Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html), das die REST-API erstellt.
```
import { Construct } from 'constructs';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import { LambdaRestApi } from 'aws-cdk-lib/aws-apigateway';
import { RetentionDays } from 'aws-cdk-lib/aws-logs';
import { CfnOutput } from 'aws-cdk-lib';
export class HelloWorld extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
const helloFunction = new NodejsFunction(this, 'function', {
environment: {
Powertools_SERVICE_NAME: 'helloWorld',
LOG_LEVEL: 'INFO',
},
logRetention: RetentionDays.ONE_WEEK,
});
const api = new LambdaRestApi(this, 'apigw', {
handler: helloFunction,
});
new CfnOutput(this, 'apiUrl', {
exportName: 'apiUrl',
value: api.url,
});
}
}
```
1. Öffnen Sie **hello-world-stack.ts.** Dies ist der Code, der Ihren [AWS CDK -Stack](https://docs.aws.amazon.com/cdk/v2/guide/stacks.html) definiert. Ersetzen Sie den Code mit Folgendem:
```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { HelloWorld } from './hello-world';
export class HelloWorldStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new HelloWorld(this, 'hello-world');
}
}
```
1. Kehren Sie zum Projektverzeichnis zurück.
```
cd hello-world
```
1. Stellen Sie die Anwendung bereit.
```
cdk deploy
```
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?ExportName==`apiUrl`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html) aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter [Arbeiten mit Protokollen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) im *AWS Serverless Application Model -Entwicklerhandbuch*.
```
sam logs --stack-name HelloWorldStack
```
Das Ergebnis sieht folgendermaßen aus:
```
2025/01/31/[$LATEST]2ca67f180dcd4d3e88b5d68576740c8e 2025-08-31T14:48:37.047000 START RequestId: 19ad1007-ff67-40ce-9afe-0af0a9eb512c Version: $LATEST
2025/01/31/[$LATEST]2ca67f180dcd4d3e88b5d68576740c8e 2025-08-31T14:48:37.050000 {
"level": "INFO",
"message": "This is an INFO log - sending HTTP 200 - hello world response",
"service": "helloWorld",
"timestamp": "2025-08-31T14:48:37.048Z",
"xray_trace_id": "1-630f74c4-2b080cf77680a04f2362bcf2"
}
2025/01/31/[$LATEST]2ca67f180dcd4d3e88b5d68576740c8e 2025-08-31T14:48:37.082000 END RequestId: 19ad1007-ff67-40ce-9afe-0af0a9eb512c
2025/01/31/[$LATEST]2ca67f180dcd4d3e88b5d68576740c8e 2025-08-31T14:48:37.082000 REPORT RequestId: 19ad1007-ff67-40ce-9afe-0af0a9eb512c Duration: 34.60 ms Billed Duration: 35 ms Memory Size: 128 MB Max Memory Used: 57 MB Init Duration: 173.48 ms
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```
## Anzeigen von Protokollen in der Lambda-Konsole
Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.
Wenn Ihr Code über den eingebetteten **Code**-Editor getestet werden kann, finden Sie Protokolle in den **Ausführungsergebnissen**. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die **Protokollausgabe** im Abschnitt **Details**.
## Logs in der CloudWatch Konsole anzeigen
Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufe anzuzeigen.
**Um Protokolle auf der Konsole anzuzeigen CloudWatch**
1. Öffnen Sie die [Seite Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home?#logs:) auf der CloudWatch Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (***your-function-name*/aws/lambda/**).
1. Wählen Sie eine Protokollstream aus.
Jeder Protokoll-Stream entspricht einer [Instance Ihrer Funktion](lambda-runtime-environment.md). Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instanzen für gleichzeitige Aufrufe erstellt werden. Um Protokolle für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.
# TypeScript Code nachverfolgen in AWS Lambda
Lambda lässt sich integrieren AWS X-Ray , um Ihnen zu helfen, Lambda-Anwendungen zu verfolgen, zu debuggen und zu optimieren. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, die Lambda-Funktionen und andere AWS -Services enthalten können.
Um Protokollierungsdaten an X-Ray zu senden, können Sie eine von drei SDK-Bibliotheken verwenden:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Eine sichere, produktionsbereite und AWS unterstützte Distribution des () SDK. OpenTelemetry OTel
+ [AWS X-Ray SDK für Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html) — Ein SDK zum Generieren und Senden von Trace-Daten an X-Ray.
+ [Powertools for AWS Lambda (TypeScript)](https://docs.aws.amazon.com/powertools/typescript/latest/) — Ein Entwickler-Toolkit zur Implementierung von Best Practices für Serverless und zur Steigerung der Entwicklergeschwindigkeit.
Jedes SDKs bietet Möglichkeiten, Ihre Telemetriedaten an den X-Ray-Dienst zu senden. Sie können dann mit X-Ray die Leistungsmetriken Ihrer Anwendung anzeigen, filtern und erhalten, um Probleme und Möglichkeiten zur Optimierung zu identifizieren.
**Wichtig**
X-Ray und Powertools für AWS Lambda SDKs sind Teil einer eng integrierten Instrumentierungslösung von AWS. Die ADOT Lambda Layers sind Teil eines branchenweiten Standards für die Verfolgung von Instrumenten, die im Allgemeinen mehr Daten erfassen, aber möglicherweise nicht für alle Anwendungsfälle geeignet sind. Sie können die end-to-end Ablaufverfolgung in X-Ray mit beiden Lösungen implementieren. Weitere Informationen zur Auswahl zwischen beiden finden Sie unter [Wählen zwischen der AWS Distribution für Open Telemetry und](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs
**Topics**
+ [
## Powertools für AWS Lambda (TypeScript) und für die Nachverfolgung verwenden AWS SAM
](#typescript-tracing-sam)
+ [
## Verwenden von Powertools for AWS Lambda (TypeScript) und AWS CDK for tracing
](#typescript-tracing-cdk)
+ [
## Interpretieren einer X-Ray-Nachverfolgung
](#typescript-tracing-interpretation)
## Powertools für AWS Lambda (TypeScript) und für die Nachverfolgung verwenden AWS SAM
Gehen Sie wie folgt vor, um mithilfe von eine Hello TypeScript World-Beispielanwendung mit integrierten [Powertools for AWS Lambda (TypeScript)](https://docs.powertools.aws.dev/lambda-typescript) -Modulen herunterzuladen, zu erstellen und bereitzustellen. AWS SAM Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Node.js
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS SAM Beispielanwendung bereit**
1. Initialisieren Sie die Anwendung mithilfe der Hello TypeScript World-Vorlage.
```
sam init --app-template hello-world-powertools-typescript --name sam-app --package-type Zip --runtime nodejs24.x --no-tracing
```
1. Entwickeln Sie die App.
```
cd sam-app && sam build
```
1. Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
1. Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
**Anmerkung**
Für ist **HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung?** , stellen Sie sicher, dass Sie eintreten`y`.
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
XRay Event [revision 1] at (2023-01-31T11:29:40.527000) with id (1-11a2222-111a222222cb33de3b95daf9) and duration (0.483s)
- 0.425s - sam-app/Prod [HTTP: 200]
- 0.422s - Lambda [HTTP: 200]
- 0.406s - sam-app-HelloWorldFunction-Xyzv11a1bcde [HTTP: 200]
- 0.172s - sam-app-HelloWorldFunction-Xyzv11a1bcde
- 0.179s - Initialization
- 0.112s - Invocation
- 0.052s - ## app.lambdaHandler
- 0.001s - ### MySubSegment
- 0.059s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```
X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.
## Verwenden von Powertools for AWS Lambda (TypeScript) und AWS CDK for tracing
Gehen Sie wie folgt vor, um mithilfe von eine Hello TypeScript World-Beispielanwendung mit integrierten [Powertools for AWS Lambda (TypeScript)](https://docs.powertools.aws.dev/lambda-typescript) -Modulen herunterzuladen, zu erstellen und bereitzustellen. AWS CDK Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine `hello world`-Nachricht zurück.
**Voraussetzungen**
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ Node.js
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK Ausführung 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI Version 1.75 oder höher](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter [Upgrade der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Stellen Sie eine AWS Cloud Development Kit (AWS CDK) Beispielanwendung bereit**
1. Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
1. Initialisieren Sie die App.
```
cdk init app --language typescript
```
1. Fügen Sie das [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda)-Paket als Entwicklungsabhängigkeit hinzu.
```
npm install -D @types/aws-lambda
```
1. Installieren Sie das [Tracer-Dienstprogramm](https://docs.aws.amazon.com/powertools/typescript/latest/features/tracer/) von Powertools.
```
npm install @aws-lambda-powertools/tracer
```
1. Öffnen Sie das **lib**-Verzeichnis. Sie sollten eine Datei namens **hello-world-stack.ts** sehen. Erstellen Sie neue zwei neue Dateien in diesem Verzeichnis: **hello-world.function.ts** und **hello-world.ts**.
1. Öffnen Sie **hello-world.function.ts** und fügen Sie den folgenden Code in die Datei ein. Dies ist der Code für die Lambda-Funktion.
```
import { APIGatewayEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { Tracer } from '@aws-lambda-powertools/tracer';
const tracer = new Tracer();
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
// Get facade segment created by Lambda
const segment = tracer.getSegment();
// Create subsegment for the function and set it as active
const handlerSegment = segment.addNewSubsegment(`## ${process.env._HANDLER}`);
tracer.setSegment(handlerSegment);
// Annotate the subsegment with the cold start and serviceName
tracer.annotateColdStart();
tracer.addServiceNameAnnotation();
// Add annotation for the awsRequestId
tracer.putAnnotation('awsRequestId', context.awsRequestId);
// Create another subsegment and set it as active
const subsegment = handlerSegment.addNewSubsegment('### MySubSegment');
tracer.setSegment(subsegment);
let response: APIGatewayProxyResult = {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
// Close subsegments (the Lambda one is closed automatically)
subsegment.close(); // (### MySubSegment)
handlerSegment.close(); // (## index.handler)
// Set the facade segment as active again (the one created by Lambda)
tracer.setSegment(segment);
return response;
};
```
1. Öffnen Sie **hello-world.ts** und fügen Sie den folgenden Code in die Datei ein. Dies enthält das [NodejsFunction Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html), das die Lambda-Funktion erstellt, Umgebungsvariablen für Powertools konfiguriert und die Protokollspeicherung auf eine Woche festlegt. Es beinhaltet auch das [LambdaRestApi Konstrukt](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html), das die REST-API erstellt.
```
import { Construct } from 'constructs';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import { LambdaRestApi } from 'aws-cdk-lib/aws-apigateway';
import { CfnOutput } from 'aws-cdk-lib';
import { Tracing } from 'aws-cdk-lib/aws-lambda';
export class HelloWorld extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
const helloFunction = new NodejsFunction(this, 'function', {
environment: {
POWERTOOLS_SERVICE_NAME: 'helloWorld',
},
tracing: Tracing.ACTIVE,
});
const api = new LambdaRestApi(this, 'apigw', {
handler: helloFunction,
});
new CfnOutput(this, 'apiUrl', {
exportName: 'apiUrl',
value: api.url,
});
}
}
```
1. Öffnen Sie **hello-world-stack.ts.** Dies ist der Code, der Ihren [AWS CDK -Stack](https://docs.aws.amazon.com/cdk/v2/guide/stacks.html) definiert. Ersetzen Sie den Code mit Folgendem:
```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { HelloWorld } from './hello-world';
export class HelloWorldStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new HelloWorld(this, 'hello-world');
}
}
```
1. Stellen Sie die Anwendung bereit.
```
cd ..
cdk deploy
```
1. Rufen Sie die URL der bereitgestellten Anwendung ab:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?ExportName==`apiUrl`].OutputValue' --output text
```
1. Rufen Sie den API-Endpunkt auf:
```
curl
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```
1. Führen Sie [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html) aus, um die Traces für die Funktion zu erhalten.
```
sam traces
```
Das Nachverfolgungsergebnis sieht folgendermaßen aus:
```
XRay Event [revision 1] at (2023-01-31T11:50:06.997000) with id (1-11a2222-111a222222cb33de3b95daf9) and duration (0.449s)
- 0.350s - HelloWorldStack-helloworldfunction111A2BCD-Xyzv11a1bcde [HTTP: 200]
- 0.157s - HelloWorldStack-helloworldfunction111A2BCD-Xyzv11a1bcde
- 0.169s - Initialization
- 0.058s - Invocation
- 0.055s - ## index.handler
- 0.000s - ### MySubSegment
- 0.099s - Overhead
```
1. Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```
## Interpretieren einer X-Ray-Nachverfolgung
Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Die [X-Ray-Trace-Map](https://docs.aws.amazon.com/xray/latest/devguide/xray-console-servicemap.html) liefert Informationen über Ihre Anwendung und alle ihre Komponenten. Das folgende Beispiel zeigt eine Nachverfolgung aus der Beispielanwendung:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sample-typescript-servicemap.png)