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.
# ASP.NET-Anwendungen bereitstellen
Sie können nicht nur ereignisgesteuerte Funktionen hosten, sondern auch .NET mit Lambda verwenden, um leichtgewichtige ASP.NET-Anwendungen zu hosten. Sie können ASP.NET-Anwendungen mithilfe des `Amazon.Lambda.AspNetCoreServer`-NuGet-Pakets erstellen und bereitstellen. In diesem Abschnitt erfahren Sie, wie Sie eine ASP.NET-Web-API mit dem .NET Lambda CLI-Tooling in Lambda bereitstellen.
**Topics**
+ [Voraussetzungen](#csharp-package-asp-prerequisites)
+ [Eine ASP.NET-Web-API für Lambda bereitstellen](#csharp-package-asp-deploy-api)
+ [Bereitstellung minimaler ASP.NET-APIs für Lambda](#csharp-package-asp-deploy-minimal)
## Voraussetzungen
**.NET 8-SDK**
Installieren Sie das [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)-SDK und ASP.NET Core Runtime.
**Amazon.Lambda.Tools**
Verwenden Sie zum Erstellen Ihrer Lambda-Funktionen die [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools)-[.NET Global Tools-Erweiterung](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/). Um Amazon.Lambda.Tools zu installieren, führen Sie den folgenden Befehl aus:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Weitere Informationen über die Amazon.Lambda.Tools .NET CLI-Erweiterung finden Sie im [AWS-Erweiterungen für .NET-CLI](https://github.com/aws/aws-extensions-for-dotnet-cli)-Repository auf GitHub.
**Amazon.Lambda.Templates**
Verwenden Sie das [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates)-NuGet-Paket, um Ihren Lambda-Funktionscode zu generieren. Zur Installation dieses Vorlagenpakets führen Sie den folgenden Befehl aus:
```
dotnet new --install Amazon.Lambda.Templates
```
## Eine ASP.NET-Web-API für Lambda bereitstellen
Um eine Web-API mit ASP.NET bereitzustellen, können Sie die .NET-Lambda-Vorlagen verwenden, um ein neues Web-API-Projekt zu erstellen. Verwenden Sie den folgenden Befehl, um ein neues ASP.NET-Web-API-Projekt zu initialisieren. Im Beispielbefehl nennen wir das Projekt `AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Mit diesem Befehl werden die folgenden Dateien und Verzeichnisse in Ihrem Projektverzeichnis erstellt.
```
.
└── AspNetOnLambda
├── src
│ └── AspNetOnLambda
│ ├── AspNetOnLambda.csproj
│ ├── Controllers
│ │ └── ValuesController.cs
│ ├── LambdaEntryPoint.cs
│ ├── LocalEntryPoint.cs
│ ├── Readme.md
│ ├── Startup.cs
│ ├── appsettings.Development.json
│ ├── appsettings.json
│ ├── aws-lambda-tools-defaults.json
│ └── serverless.template
└── test
└── AspNetOnLambda.Tests
├── AspNetOnLambda.Tests.csproj
├── SampleRequests
│ └── ValuesController-Get.json
├── ValuesControllerTests.cs
└── appsettings.json
```
Wenn Lambda Ihre Funktion aufruft, wird als Einstiegspunkt die Datei `LambdaEntryPoint.cs` verwendet. Die von der .NET Lambda-Vorlage erstellte Datei enthält den folgenden Code.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
Der von Lambda verwendete Einstiegspunkt muss von einer der drei Basisklassen im Paket `Amazon.Lambda.AspNetCoreServer` erben. Diese drei Basisklassen sind:
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
Die Standardklasse, die verwendet wird, wenn Sie Ihre `LambdaEntryPoint.cs`-Datei mit der bereitgestellten .NET Lambda-Vorlage erstellen, ist `APIGatewayProxyFunction`. Die Basisklasse, die Sie in Ihrer Funktion verwenden, hängt davon ab, welche API-Schicht vor Ihrer Lambda-Funktion steht.
Jede der drei Basisklassen enthält eine öffentliche Methode namens `FunctionHandlerAsync`. Der Name dieser Methode wird Teil der [Handler-String](csharp-handler.md#csharp-class-library-handlers) sein, die Lambda verwendet, um Ihre Funktion aufzurufen. Die `FunctionHandlerAsync`-Methode wandelt den eingehenden Ereignis-Payload in das korrekte ASP.NET-Format und die ASP.NET-Antwort zurück in einen Lambda-Antwort-Payload um. Für das gezeigte Beispielprojekt `AspNetOnLambda` würde der Handler-String wie folgt lauten.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Um die API in Lambda bereitzustellen, führen Sie die folgenden Befehle aus, um in das Verzeichnis mit Ihrer Quellcodedatei zu navigieren und Ihre Funktion mit CloudFormation bereitzustellen.
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**Tipp**
Wenn Sie eine API mit dem Befehl `dotnet lambda deploy-serverless` bereitstellen, gibt CloudFormation Ihrer Lambda-Funktion einen Namen, der auf dem Stapelnamen basiert, den Sie während der Bereitstellung angeben. Um Ihrer Lambda-Funktion einen benutzerdefinierten Namen zu geben, bearbeiten Sie die `serverless.template`-Datei, um der `AWS::Serverless::Function`-Ressource eine `FunctionName`-Eigenschaft hinzuzufügen. Weitere Informationen finden Sie unter [Namenstyp](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) im *CloudFormation-Benutzerhandbuch*.
## Bereitstellung minimaler ASP.NET-APIs für Lambda
Um eine ASP.NET-Minimal-API für Lambda bereitzustellen, können Sie die .NET-Lambda-Vorlagen verwenden, um ein neues Minimal-API-Projekt zu erstellen. Verwenden Sie den folgenden Befehl, um ein neues minimales API-Projekt zu initialisieren. In diesem Beispiel nennen wir das Projekt `MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
Der Befehl erstellt die folgenden Dateien und Verzeichnisse in Ihrem Projektverzeichnis.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
Die Datei `Program.cs` enthält den folgenden Code.
```
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Add AWS Lambda support. When application is run in Lambda Kestrel is swapped out as the web server with Amazon.Lambda.AspNetCoreServer. This
// package will act as the webserver translating request and responses between the Lambda event source and ASP.NET Core.
builder.Services.AddAWSLambdaHosting(LambdaEventSource.RestApi);
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.MapGet("/", () => "Welcome to running ASP.NET Core Minimal API on AWS Lambda");
app.Run();
```
Um Ihre Minimal-API für die Ausführung auf Lambda zu konfigurieren, müssen Sie diesen Code möglicherweise bearbeiten, damit Anfragen und Antworten zwischen Lambda und ASP.NET Core ordnungsgemäß übersetzt werden. Standardmäßig ist die Funktion für eine REST-API-Ereignisquelle konfiguriert. Für eine HTTP-API oder einen Application Load Balancer ersetzen Sie `(LambdaEventSource.RestApi)` durch eine der folgenden Optionen:
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Um Ihre Minimal-API in Lambda bereitzustellen, führen Sie die folgenden Befehle aus, um in das Verzeichnis mit Ihrer Quellcodedatei zu navigieren und Ihre Funktion mit CloudFormation bereitzustellen.
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```