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. # 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 ```