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.
# Bereitstellen von .NET-Lambda-Funktionen mit Container-Images
Es gibt drei Möglichkeiten, ein Container-Image für eine .NET-Lambda-Funktion zu erstellen:
+ [Verwenden eines AWS Basis-Images für.NET](#csharp-image-instructions)
Die [AWS -Basis-Images](images-create.md#runtimes-images-lp) sind mit einer Sprachlaufzeit, einem Laufzeitschnittstellen-Client zur Verwaltung der Interaktion zwischen Lambda und Ihrem Funktionscode und einem Laufzeitschnittstellen-Emulator für lokale Tests vorinstalliert.
+ [Es wird ein AWS reines Betriebssystem-Basis-Image verwendet](images-create.md#runtimes-images-provided)
[AWS Basis-Images nur für Betriebssysteme](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) sowie für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie Node.js 19. Sie können reine OS-Basis-Images auch verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für .NET](#csharp-image-clients) in das Image aufnehmen.
+ [Verwenden eines Nicht-Basis-Images AWS ](#csharp-image-clients)
Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für .NET](#csharp-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.NET
](#csharp-image-base)
+ [
## Verwenden eines AWS Basis-Images für.NET
](#csharp-image-instructions)
+ [
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
](#csharp-image-clients)
## AWS Basis-Images für.NET
AWS stellt die folgenden Basis-Images für.NET bereit:
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile für .NET 10 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | 14. November 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile für .NET 9 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | 10. November 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile für .NET 8 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | 10. November 2026 |
Amazon ECR-Repository: [gallery.ecr. aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Verwenden eines AWS Basis-Images für.NET
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [.NET SDK](https://dotnet.microsoft.com/download) – Die folgenden Schritte verwenden das .NET 8-Basis-Image. Stellen Sie sicher, dass Ihre .NET-Version mit der Version des [Basis-Images](https://gallery.ecr.aws/lambda/dotnet) übereinstimmt, die Sie in Ihrer Docker-Datei angeben.
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
### Erstellen und Bereitstellen eines Images mithilfe eines Basis-Images
In den folgenden Schritten verwenden Sie [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) und [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools), um ein.NET-Projekt zu erstellen. Anschließend erstellen Sie ein Docker-Image, laden das Image auf Amazon ECR hoch und stellen es auf einer Lambda-Funktion bereit.
1. Installieren Sie das [Amazon.Lambda.Templates-Paket.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Erstellen Sie ein .NET-Projekt mithilfe der `lambda.image.EmptyFunction`-Vorlage.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
Die Projektdateien werden im `MyFunction/src/MyFunction`-Verzeichnis gespeichert:
+ **aws-lambda-tools-defaults.json**: Gibt die Befehlszeilenoptionen für die Bereitstellung Ihrer Lambda-Funktion an.
+ **Function.cs**: Der Funktionscode Ihres Lambda-Handlers. Dies ist eine C\$1-Vorlage mit der `Amazon.Lambda.Core`-Standardbibliothek und einem `LambdaSerializer`-Standardattribut. Weitere Informationen über Serialisierungsanforderungen und -optionen finden Sie unter [Serialisierung in C\$1-Lambda-Funktionen](csharp-handler.md#csharp-handler-serializer). Sie können den bereitgestellten Code zum Testen verwenden oder ihn durch Ihren eigenen ersetzen.
+ **MyFunction.csproj**: Eine [.NET-Projektdatei](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files), die die Dateien und Assemblys auflistet, aus denen Ihre Anwendung besteht.
+ **Dockerfile**: Sie können die bereitgestellte Docker-Datei zum Testen verwenden oder sie durch Ihre eigene ersetzen. Wenn Sie Ihre eigenen verwenden, stellen Sie sicher, dass Sie:
+ Setzen Sie die `FROM`-Eigenschaft auf den [URI des Basis-Images](https://gallery.ecr.aws/lambda/dotnet). Das Basis-Image und das `TargetFramework` in der Datei `MyFunction.csproj` müssen beide dieselbe .NET-Version verwenden. Um beispielsweise .NET 9 zu verwenden:
+ Docker-Datei: `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj: `net9.0`
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest. Das sollte mit dem `image-command` in `aws-lambda-tools-defaults.json` übereinstimmen.
1. Installieren Sie Amazon.Lambda.Tools [.NET Global Tool](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/).
```
dotnet tool install -g Amazon.Lambda.Tools
```
Wenn Amazon.Lambda.Tools bereits installiert ist, vergewissern Sie sich, dass Sie über die neueste Version verfügen.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Ändern Sie das Verzeichnis zu `MyFunction/src/MyFunction`, sofern Sie dies noch nicht getan haben.
```
cd src/MyFunction
```
1. Verwenden Sie Amazon.Lambda.Tools, um das Docker-Image zu erstellen, es in ein neues Amazon-ECR-Repository zu verschieben und die Lambda-Funktion bereitzustellen.
Für `--function-role` geben Sie den Rollennamen – nicht den Amazon-Ressourcenname (ARN) – der [Ausführungsrolle](lambda-intro-execution-role.md) für die Funktion an. Beispiel, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Weitere Informationen zum Amazon.Lambda.Tools .NET Global Tool finden Sie im [AWS Extensions](https://github.com/aws/aws-extensions-for-dotnet-cli) for .NET CLI Repository unter. GitHub
1. Die Funktion aufrufen.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Wenn alles erfolgreich ist, sehen Sie eine Antwort ähnlich der folgenden:
```
Payload:
{"Lower":"testing the function","Upper":"TESTING THE FUNCTION"}
Log Tail:
INIT_REPORT Init Duration: 9999.81 ms Phase: init Status: timeout
START RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Version: $LATEST
END RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed
REPORT RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Duration: 3173.06 ms Billed Duration: 3174 ms Memory Size: 512 MB Max Memory Used: 24 MB
```
1. Löschen Sie die Lambda-Funktion.
```
dotnet lambda delete-function MyFunction
```
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
Wenn Sie ein [OS-Basis-Image](images-create.md#runtimes-images-provided) oder ein alternatives Basis-Image verwenden, müssen Sie den Laufzeitschnittstellen-Client in das Image einbinden. Der Laufzeitschnittstellen-Client erweitert die [Laufzeit-API](runtimes-api.md), die die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet.
Das folgende Beispiel zeigt, wie Sie mithilfe eines AWS Nicht-Base-Images ein Container-Image für .NET erstellen und wie Sie das [Amazon.Lambda hinzufügen. RuntimeSupport ](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)Paket, das der Lambda-Runtime-Interface-Client für .NET ist. Das Beispiel-Dockerfile verwendet das Basis-Image „Microsoft .NET 8“.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [.NET SDK](https://dotnet.microsoft.com/download) — Für die folgenden Schritte wird ein .NET 9-Basisimage verwendet. Stellen Sie sicher, dass Ihre .NET-Version mit der Version des Basis-Images übereinstimmt, die Sie in Ihrer Docker-Datei angeben.
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
### Erstellen und Bereitstellen eines Images mithilfe eines alternativen Basis-Images
1. Installieren Sie das [Amazon.Lambda.Templates-Paket.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Erstellen Sie ein .NET-Projekt mithilfe der `lambda.CustomRuntimeFunction`-Vorlage. [Diese Vorlage enthält das Amazon.Lambda. RuntimeSupport](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)Paket.
```
dotnet new lambda.CustomRuntimeFunction --name MyFunction --region us-east-1
```
1. Navigieren Sie zum `MyFunction/src/MyFunction` Verzeichnis . Hier werden die Projektdateien gespeichert. Prüfen Sie die folgenden Dateien:
+ **aws-lambda-tools-defaults.json** — In dieser Datei geben Sie die Befehlszeilenoptionen an, wenn Sie Ihre Lambda-Funktion bereitstellen.
+ **Function.cs** – Der Code enthält eine Klasse mit einer `Main`-Methode, die die Bibliothek `Amazon.Lambda.RuntimeSupport` als Bootstrap initialisiert. Die `Main`-Methode ist der Einstiegspunkt für den Prozess der Funktion. Die `Main`-Methode verpackt den Funktionshandler in einen Wrapper, mit dem der Bootstrap arbeiten kann. Weitere Informationen finden Sie unter Amazon.Lambda [verwenden. RuntimeSupport als Klassenbibliothek im Repository](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library). GitHub
+ **MyFunction.csproj — [Eine.NET-Projektdatei](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files)**, die die Dateien und Assemblys auflistet, aus denen Ihre Anwendung besteht.
+ **Readme.md** – Diese Datei enthält weitere Informationen zur Lambda-Beispielfunktion.
1. Öffnen Sie die Datei `aws-lambda-tools-defaults.json` und fügen Sie die folgenden Zeilen hinzu:
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-type**: Definiert das Bereitstellungspaket als Container-Image.
+ **docker-host-build-output-dir**: Legt das Ausgabeverzeichnis für den Build-Prozess fest.
**Example aws-lambda-tools-defaults.json**
```
{
"Information": [
"This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
"To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
"dotnet lambda help",
"All the command line options for the Lambda command can be specified in this file."
],
"profile": "",
"region": "us-east-1",
"configuration": "Release",
"function-runtime": "provided.al2023",
"function-memory-size": 256,
"function-timeout": 30,
"function-handler": "bootstrap",
"msbuild-parameters": "--self-contained true",
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
}
```
1. Erstellen Sie ein Dockerfile in Verzeichnis `MyFunction/src/MyFunction`. Das folgende Beispiel-Dockerfile verwendet ein Microsoft .NET-Basisimage anstelle eines [AWS -Basis-Images](#csharp-image-base).
+ Legen Sie `FROM`-Eigenschaft auf die Kennung des Basis-Images fest. Das Basis-Image und das `TargetFramework` in der Datei `MyFunction.csproj` müssen beide dieselbe .NET-Version verwenden.
+ Verwenden Sie den `COPY`-Befehl, um die Funktion in das Verzeichnis `/var/task` 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 Bootstrap, der die Bibliothek `Amazon.Lambda.RuntimeSupport` initialisiert.
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**
```
# You can also pull these images from DockerHub amazon/aws-lambda-dotnet:8
FROM mcr.microsoft.com/dotnet/runtime:9.0
# Set the image's internal work directory
WORKDIR /var/task
# Copy function code to Lambda-defined environment variable
COPY "bin/Release/net9.0/linux-x64" .
# Set the entrypoint to the bootstrap
ENTRYPOINT ["/usr/bin/dotnet", "exec", "/var/task/bootstrap.dll"]
```
1. Installieren Sie die Amazon.Lambda.Tools [.NET Global Tools-Erweiterung](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/).
```
dotnet tool install -g Amazon.Lambda.Tools
```
Wenn Amazon.Lambda.Tools bereits installiert ist, vergewissern Sie sich, dass Sie über die neueste Version verfügen.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Verwenden Sie Amazon.Lambda.Tools, um das Docker-Image zu erstellen, es in ein neues Amazon-ECR-Repository zu verschieben und die Lambda-Funktion bereitzustellen.
Für `--function-role` geben Sie den Rollennamen – nicht den Amazon-Ressourcenname (ARN) – der [Ausführungsrolle](lambda-intro-execution-role.md) für die Funktion an. Beispiel, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Weitere Informationen zur .NET-CLI-Erweiterung Amazon.Lambda.Tools finden Sie im [AWS Extensions](https://github.com/aws/aws-extensions-for-dotnet-cli) for .NET CLI-Repository unter. GitHub
1. Die Funktion aufrufen.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Wenn alles erfolgreich ist, sehen Sie Folgendes:
```
Payload:
"TESTING THE FUNCTION"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 1 ms Memory Size: 256 MB Max Memory Used: 12 MB
```
1. Löschen Sie die Lambda-Funktion.
```
dotnet lambda delete-function MyFunction
```