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 Node.js Lambda-Funktionen mit Container-Images bereit
Es gibt drei Möglichkeiten, ein Container-Image für eine Node.js Lambda-Funktion zu erstellen:
+ [Verwenden Sie ein Basis-Image für AWS Node.js](#nodejs-image-instructions)
Die [AWS -Basis-Images](images-create.md#runtimes-images-lp) sind mit einer Sprachlaufzeit, einem Laufzeitschnittstellen-Client zur Verwaltung der Interaktion zwischen Lambda und Ihrem Funktionscode und einem Laufzeitschnittstellen-Emulator für lokale Tests vorinstalliert.
+ [Es wird ein AWS reines Betriebssystem-Basis-Image verwendet](images-create.md#runtimes-images-provided)
[AWS OS-only Basis-Images](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) und für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie z. B. Node.js 19. Sie können auch OS-only Basis-Images verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Runtime-Interface-Client für Node.js](#nodejs-image-clients) in das Image aufnehmen.
+ [Verwenden Sie ein Image, das nicht zur AWS Basisversion gehört](#nodejs-image-clients)
Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Runtime-Interface-Client für Node.js](#nodejs-image-clients) in das Image aufnehmen.
**Tipp**
Um die Zeit zu reduzieren, die benötigt wird, bis Lambda-Container-Funktionen aktiv werden, siehe die Docker-Dokumentation unter [Verwenden mehrstufiger Builds](https://docs.docker.com/build/building/multi-stage/). Um effiziente Container-Images zu erstellen, folgen Sie den [Bewährte Methoden für das Schreiben von Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Auf dieser Seite wird erklärt, wie Sie Container-Images für Lambda erstellen, testen und bereitstellen.
**Topics**
+ [AWS Basis-Images für Node.js](#nodejs-image-base)
+ [Verwenden Sie ein Basis-Image für AWS Node.js](#nodejs-image-instructions)
+ [Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client](#nodejs-image-clients)
## AWS Basis-Images für Node.js
AWS bietet die folgenden Basis-Images für Node.js:
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| 24 | Node.js 24 | Amazon Linux 2023 | [Dockerfile für 24 Node.js GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs24.x/Dockerfile.nodejs24.x) | 30. April 2028 |
| 22 | Node.js 22 | Amazon Linux 2023 | [Dockerfile für 22 auf Node.js GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs22.x/Dockerfile.nodejs22.x) | 30. April 2027 |
Amazon ECR-Repository: [gallery.ecr. aws/lambda/node.js](https://gallery.ecr.aws/lambda/nodejs)
Die Basis-Images Node.js 20 und höher basieren auf dem [Minimal-Container-Image von Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Frühere Basis-Images verwenden Amazon Linux 2. AL2023 bietet mehrere Vorteile gegenüber Amazon Linux 2, darunter einen geringeren Bereitstellungsaufwand und aktualisierte Versionen von Bibliotheken wie `glibc`.
AL2023-based Bilder verwenden `microdnf` (symbolisiert als`dnf`) als Paketmanager anstelle von`yum`, was der Standard-Paketmanager in Amazon Linux 2 ist. `microdnf`ist eine eigenständige Implementierung von. `dnf` Eine Liste der Pakete, die in AL2023-based Images enthalten sind, finden Sie in den Spalten **Minimal Container** unter [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Weitere Informationen zu den Unterschieden zwischen AL2023 und Amazon Linux 2 finden Sie unter [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) im AWS -Compute-Blog.
**Anmerkung**
Um AL2023-based Images lokal auszuführen, auch mit AWS Serverless Application Model (AWS SAM), müssen Sie die Docker-Version 20.10.10 oder höher verwenden.
## Verwenden Sie ein Basis-Image für AWS Node.js
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Node.js
### Erstellen eines Images aus einem Base Image
**Um ein Container-Image aus einem AWS Basis-Image zu erstellen für Node.js**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie ein neues Node.js Projekt mit`npm`. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
```
npm init
```
1. Erstellen Sie eine neue Datei mit dem Namen `index.js`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example CommonJS-Handler**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Wenn Ihre Funktion von anderen Bibliotheken als den abhängt AWS SDK für JavaScript, verwenden Sie [npm](https://www.npmjs.com/), um sie Ihrem Paket hinzuzufügen.
1. Erstellen Sie eine neue Docker-Datei mit der folgenden Konfiguration:
+ Setzen Sie die `FROM`-Eigenschaft auf den [URI des Basis-Images](https://gallery.ecr.aws/lambda/nodejs).
+ Verwenden Sie den Befehl COPY, um den Funktionscode und die Laufzeitabhängigkeiten in eine [Lambda-defined Umgebungsvariable](configuration-envvars.md#configuration-envvars-runtime) zu `{LAMBDA_TASK_ROOT}` kopieren.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM {{public.ecr.aws/lambda/nodejs:22}}
# Copy function code
COPY {{index.js}} ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "{{index.handler}}" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t {{docker-image}}:{{test}} .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64-Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl unbedingt so ändern, dass stattdessen die `--platform linux/arm64`-Option verwendet wird.
### (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-Befehlssatz-Architektur erstellt haben, müssen Sie die Option `--platform linux/{{arm64}}` statt `--platform linux/{{amd64}}` verwenden.
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 Befehl [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) aus, um die Docker-CLI bei Ihrem Amazon-ECR-Registry 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 Befehl [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 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 Befehl [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name {{hello-world}} \
--image-uri {{111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest}} \
--publish
```
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
Wenn Sie ein [OS-only Basis-Image](images-create.md#runtimes-images-provided) oder ein alternatives Basis-Image verwenden, müssen Sie den Runtime-Interface-Client in Ihr Image aufnehmen. Der Laufzeitschnittstellen-Client erweitert die [Laufzeit-API](runtimes-api.md), die die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet.
Installieren Sie den [Node.js Runtime-Interface-Client](https://www.npmjs.com/package/aws-lambda-ric) mit dem npm-Paketmanager:
```
npm install aws-lambda-ric
```
Sie können den [Node.js Runtime-Interface-Client](https://github.com/aws/aws-lambda-nodejs-runtime-interface-client) auch von GitHub herunterladen.
Das folgende Beispiel zeigt, wie ein Container-Image für die Node.js Verwendung eines AWS Nicht-Basis-Images erstellt wird. Das Beispiel-Dockerfile verwendet ein `bookworm`-Basis-Image. Das Docker-File enthält den Laufzeitschnittstellen-Client.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Node.js
### Erstellen eines Images aus einem alternativen Basis-Image
**Um ein Container-Image aus einem AWS Nicht-Basis-Image zu erstellen**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie ein neues Node.js Projekt mit`npm`. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie `Enter`.
```
npm init
```
1. Erstellen Sie eine neue Datei mit dem Namen `index.js`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example CommonJS-Handler**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Erstellen Sie eine neue Docker-Datei. Das folgende Dockerfile verwendet ein `bookworm`-Basis-Image anstelle eines [AWS -Basis-Images](images-create.md#runtimes-images-lp). Das Dockerfile enthält den [Laufzeitschnittstellen-Client](https://www.npmjs.com/package/aws-lambda-ric), der das Image mit Lambda kompatibel macht. Das folgende Dockerfile verwendet einen [Build mit mehreren Phasen](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). In der ersten Phase wird ein Build-Image erstellt. Dabei handelt es sich um eine Node.js Standardumgebung, in der die Abhängigkeiten der Funktion installiert sind. In der zweiten Phase wird ein schlankeres Image erstellt, das den Funktionscode und seine Abhängigkeiten enthält. Dadurch wird die endgültige Image-Größe reduziert.
+ Legen Sie `FROM`-Eigenschaft auf die Kennung des Basis-Images fest.
+ Verwenden Sie den Befehl `COPY`, um den Funktionscode und die Laufzeitabhängigkeiten zu kopieren.
+ Legen Sie `ENTRYPOINT` auf das Modul fest, das der Docker-Container beim Start ausführen soll. In diesem Fall ist das Modul der Laufzeitschnittstellen-Client.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM {{node:20-bookworm}} as build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Install build dependencies
RUN apt-get update && \
apt-get install -y \
g++ \
make \
cmake \
unzip \
libcurl4-openssl-dev
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
WORKDIR ${FUNCTION_DIR}
# Install Node.js dependencies
RUN npm install
# Install the runtime interface client
RUN npm install aws-lambda-ric
# Grab a fresh slim copy of the image to reduce the final size
FROM {{node:20-bookworm-slim}}
# Required for Node runtimes which use npm@8.6.0+ because
# by default npm writes logs under /home/.npm and Lambda fs is read-only
ENV NPM_CONFIG_CACHE=/tmp/.npm
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
# Set runtime interface client as default command for the container runtime
ENTRYPOINT ["{{/usr/local/bin/npx", "aws-lambda-ric"}}]
# Pass the name of the function handler as an argument to the runtime
CMD ["{{index.handler}}"]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t {{docker-image}}:{{test}} .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64-Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl unbedingt so ändern, dass stattdessen die `--platform linux/arm64`-Option verwendet wird.
### (Optional) Testen Sie das Image lokal
Verwenden Sie den [Laufzeit-Schnittstellen-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/), um das Image lokal zu testen. Sie können [den Emulator in Ihr Image integrieren](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) oder ihn mit dem folgenden Verfahren auf Ihrem lokalen Computer installieren.
**Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer**
1. Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Um den arm64-Emulator zu installieren, ersetzen Sie die GitHub Repository-URL im vorherigen Befehl durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Um den arm64-Emulator zu installieren, ersetzen Sie das `$downloadLink` durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. Beachten Sie Folgendes:
+ `docker-image` ist der Image-Name und `test` ist das Tag.
+ `/usr/local/bin/npx aws-lambda-ric index.handler` ist der `ENTRYPOINT` gefolgt von dem `CMD` aus Ihrem Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
{{docker-image:test}} \
{{/usr/local/bin/npx aws-lambda-ric index.handler}}
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
{{docker-image:test}} `
{{/usr/local/bin/npx aws-lambda-ric index.handler}}
```
------
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64-Befehlssatz-Architektur erstellt haben, müssen Sie die Option `--platform linux/{{arm64}}` statt `--platform linux/{{amd64}}` verwenden.
1. Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{{{"payload":"hello world!"}}}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{{{"payload":"hello world!"}}}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill {{3766c4ab331c}}
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den Befehl [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) aus, um die Docker-CLI bei Ihrem Amazon-ECR-Registry 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 Befehl [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 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 Befehl [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 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
```