Definieren Sie den Lambda-Funktionshandler in TypeScript

Der Lambda-Funktionshandler 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.

Beispiel TypeScript Handler

Diese Beispielfunktion protokolliert den Inhalt des Ereignisobjekts und gibt den Speicherort der Protokolle zurück. Beachten Sie Folgendes:

• Bevor Sie diesen Code in einer Lambda-Funktion verwenden, müssen Sie das Paket @types/aws-lambda als Entwicklungsabhängigkeit hinzufügen. Dieses Paket enthält die Typdefinitionen für Lambda. Bei der Installation von @types/aws-lambda importiert die import-Anweisung (import ... from 'aws-lambda') 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. DefinitelyTyped GitHub

• Der Handler in diesem Beispiel ist ein ES-Modul und muss in der Datei package.json oder mithilfe der Dateierweiterung .mjs entsprechend angegeben werden. Weitere Informationen hierzu finden Sie unter Designieren eines Funktionshandlers als ES-Modul.

import { Handler } from 'aws-lambda';

export const handler: Handler = async (event, context) => {
    console.log('EVENT: \n' + JSON.stringify(event, null, 2));
    return context.logStreamName;
};

Die Laufzeit übergibt Argumente an die Handler-Methode. Das erste Argument ist das Objekt event, das Informationen aus dem Aufrufer enthält. Der Aufrufer übergibt diese Informationen als Zeichenfolge im JSON-Format, wenn er Invoke, aufruft, und die Laufzeit konvertiert sie in ein Objekt. Wenn ein AWS Dienst Ihre Funktion aufruft, variiert die Ereignisstruktur je nach Dienst. Wir empfehlen TypeScript, Typanmerkungen für das Ereignisobjekt zu verwenden. Weitere Informationen finden Sie unter Typen für das Ereignisobjekt verwenden.

Das zweite Argument ist das Context-Objekt, das Informationen über den Aufruf, die Funktion und die Ausführungsumgebung enthält. Im vorherigen Beispiel ruft die Funktion den Namen des Protokollstreams aus dem Context-Objekt ab und gibt ihn an den Aufrufer zurück.

Sie können ein Callback-Argument verwenden, ist eine Funktion, die Sie in nicht-asynchronen Handlern aufrufen können, um eine Antwort zu senden. Wir empfehlen Ihnen, Async/Await anstelle von Callback zu verwenden. Async/Await bietet eine verbesserte Lesbarkeit, Fehlerbehandlung und Effizienz. Weitere Informationen zu den Unterschieden zwischen Async/Await und Callbacks finden Sie unter Callbacks verwenden.

Verwenden von async/await

Wenn Ihr Code eine asynchrone Aufgabe ausführt, verwenden Sie das Async-/Await, um sicherzustellen, dass die Ausführung des Handler beendet wird. Async/Await ist eine präzise und lesbare Methode, um asynchronen Code in Node.js zu schreiben, ohne dass verschachtelte Callbacks oder Verkettungsversprechen erforderlich sind. Mit Async/Await können Sie Code schreiben, der sich wie synchroner Code liest, aber dennoch asynchron und blockierungsfrei ist.

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.

Beispiel TypeScript Funktion — asynchron

In diesem Beispiel wird fetch verwendet, das in der nodejs18.x-Laufzeit verfügbar ist. Beachten Sie Folgendes:

• Bevor Sie diesen Code in einer Lambda-Funktion verwenden, müssen Sie das Paket @types/aws-lambda als Entwicklungsabhängigkeit hinzufügen. Dieses Paket enthält die Typdefinitionen für Lambda. Bei der Installation von @types/aws-lambda importiert die import-Anweisung (import ... from 'aws-lambda') 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. DefinitelyTyped GitHub

• Der Handler in diesem Beispiel ist ein ES-Modul und muss in der Datei package.json oder mithilfe der Dateierweiterung .mjs entsprechend angegeben werden. Weitere Informationen hierzu finden Sie unter Designieren eines Funktionshandlers als ES-Modul.

import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
const url = 'https://aws.amazon.com/';
export const lambdaHandler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
    try {
        // fetch is available with Node.js 18
        const res = await fetch(url);
        return {
            statusCode: res.status,
            body: JSON.stringify({
                message: await res.text(),
            }),
        };
    } catch (err) {
        console.log(err);
        return {
            statusCode: 500,
            body: JSON.stringify({
                message: 'some error happened',
            }),
        };
    }
};

Callbacks verwenden

Wir empfehlen, dass Sie Async/Await verwenden, um den Funktionshandler zu deklarieren, anstatt Callbacks zu verwenden. Async/Await ist aus mehreren Gründen eine bessere Wahl:

• Lesbarkeit: Async/Await-Code ist einfacher zu lesen und zu verstehen als Callback-Code, der schnell schwer zu verstehen sein kann und in die Callback-Hölle führen kann.

• Debugging und Fehlerbehandlung: Das Debuggen von Callback-basiertem Code kann schwierig sein. Der Aufrufliste kann schwer zu folgen sein und Fehler können leicht verschluckt werden. Mit Async/Await können Sie Try/Catch-Blöcke verwenden, um Fehler zu behandeln.

• Effizienz: Callbacks erfordern oft das Umschalten zwischen verschiedenen Teilen des Codes. Async/Await kann die Anzahl der Kontextwechsel reduzieren, was zu effizienterem Code führt.

Wenn Sie in Ihrem Handler verwenden, wird die Funktion so lange ausgeführt, bis die Ereignisschleife leer ist oder eine Zeitüberschreitung 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 context.callback Loop auf false WaitsFor EmptyEvent setzen.

Die Callback-Funktion verwendet zwei Argumente, einen Error und eine Antwort. Das Response-Objekt muss mit kompatibel sei JSON.stringify.

Beispiel TypeScript Funktion mit Callback

Diese Beispielfunktion empfängt ein Ereignis von Amazon API Gateway, protokolliert die Ereignis- und Kontextobjekte und gibt dann eine Antwort an API Gateway zurück. Beachten Sie Folgendes:

• Bevor Sie diesen Code in einer Lambda-Funktion verwenden, müssen Sie das Paket @types/aws-lambda als Entwicklungsabhängigkeit hinzufügen. Dieses Paket enthält die Typdefinitionen für Lambda. Bei der Installation von @types/aws-lambda importiert die import-Anweisung (import ... from 'aws-lambda') 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. DefinitelyTyped GitHub

• Der Handler in diesem Beispiel ist ein ES-Modul und muss in der Datei package.json oder mithilfe der Dateierweiterung .mjs entsprechend angegeben werden. Weitere Informationen hierzu finden Sie unter Designieren eines Funktionshandlers als ES-Modul.

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',
        }),
    });
};

Typen für das Ereignisobjekt verwenden

Wir empfehlen, dass Sie keinen Typ für die Handler-Argumente und den Rückgabetyp verwenden, da Sie die Möglichkeit verlieren, Typen zu überprüfen. Generieren Sie stattdessen ein Ereignis mit demselben lokalen AWS Serverless Application Model CLI-Befehl generate-event oder verwenden Sie eine Open-Source-Definition aus dem Paket @types /aws-lambda.

Generieren eines Ereignisses mit dem Befehl sam local generate-event

1. Generieren Sie ein Amazon Simple Storage Service (Amazon S3)-Proxy-Ereignis.

   sam local generate-event s3 put >> S3PutEvent.json

2. Verwenden Sie das Quicktype-Hilfsprogramm, um Typdefinitionen aus der S3-.json-Datei zu generieren. PutEvent

   npm install -g quicktype
   quicktype S3PutEvent.json -o S3PutEvent.ts

3. Verwenden Sie die generierten Typen in Ihrem Code.

   import { S3PutEvent } from './S3PutEvent';
   
   export const lambdaHandler = async (event: S3PutEvent): Promise<void> => {
     event.Records.map((record) => console.log(record.s3.object.key));
   };

Generieren eines Ereignisses mit einer Open-Source-Definition aus dem @types/aws-lambda-Paket

1. Fügen Sie das @types/aws-lambda-Paket als Entwicklungsabhängigkeit hinzu.

   npm install -D @types/aws-lambda

2. Verwenden Sie die Typen in Ihrem Code.

   import { S3Event } from "aws-lambda";
   
   export const lambdaHandler = async (event: S3Event): Promise<void> => {
     event.Records.map((record) => console.log(record.s3.object.key));
   };