Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déployez des applications ASP.NET
Outre l’hébergement de fonctions événementielles, vous pouvez également utiliser .NET avec Lambda pour héberger des applications ASP.NET légères. Vous pouvez créer et déployer des applications ASP.NET à l’aide du package NuGet `Amazon.Lambda.AspNetCoreServer`. Dans cette section, vous apprendrez à déployer une API web ASP.NET sur Lambda à l’aide de l’outillage de la CLI .NET Lambda.
**Topics**
+ [Prérequis](#csharp-package-asp-prerequisites)
+ [Déploiement d’une API Web ASP.NET sur Lambda](#csharp-package-asp-deploy-api)
+ [Déploiement des API minimales ASP.NET sur Lambda](#csharp-package-asp-deploy-minimal)
## Prérequis
**Kit SDK .NET 8**
Installez l’environnement d’exécution ASP.NET Core et le kit SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**Amazon.Lambda.Tools**
Pour créer vos fonctions Lambda, utilisez l’[https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools) [extension outils globaux .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/). Pour installer Amazon.Lambda.Tools, exécutez la commande suivante :
```
dotnet tool install -g Amazon.Lambda.Tools
```
Pour en savoir plus sur l’extension CLI .NET Amazon.Lambda.Tools, consultez le référentiel [Extensions pour la CLI .NET AWS](https://github.com/aws/aws-extensions-for-dotnet-cli) dans GitHub.
**Amazon.Lambda.Templates**
Pour générer votre code de fonction Lambda, utilisez le package NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates). Pour installer ce package de modèle, exécutez la commande suivante :
```
dotnet new --install Amazon.Lambda.Templates
```
## Déploiement d’une API Web ASP.NET sur Lambda
Pour déployer une API web à l’aide d’ASP.NET, vous pouvez utiliser les modèles Lambda .NET pour créer un nouveau projet d’API web. Utilisez la commande suivante pour initialiser un nouveau projet d’API web ASP.NET. Dans l’exemple de commande, nous nommons le projet `AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Cette commande crée les fichiers et répertoires suivants dans le répertoire de votre projet.
```
.
└── 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
```
Lorsque Lambda invoque votre fonction, le point d’entrée qu’elle utilise est le fichier `LambdaEntryPoint.cs`. Le fichier créé par le modèle Lambda .NET contient le code suivant.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
Le point d’entrée utilisé par Lambda doit hériter de l’une des trois classes de base du package `Amazon.Lambda.AspNetCoreServer`. Ces trois classes de base sont les suivantes :
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
La classe par défaut utilisée lorsque vous créez votre fichier `LambdaEntryPoint.cs` à l’aide du modèle Lambda .NET fourni est `APIGatewayProxyFunction`. La classe de base que vous utilisez dans votre fonction dépend de la couche d’API qui se trouve devant votre fonction Lambda.
Chacune des trois classes de base contient une méthode publique appelée `FunctionHandlerAsync`. Le nom de cette méthode fera partie de la [chaîne du gestionnaire](csharp-handler.md#csharp-class-library-handlers) que Lambda utilise pour invoquer votre fonction. La méthode `FunctionHandlerAsync` transforme la charge utile de l’événement entrant dans le format ASP.NET correct et la réponse ASP.NET en une charge utile de réponse Lambda. Pour l’exemple de projet `AspNetOnLambda` affiché, la chaîne du gestionnaire serait la suivante.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Pour déployer l’API sur Lambda, exécutez les commandes suivantes pour accéder au répertoire contenant votre fichier de code source et déployer votre fonction à l’aide de CloudFormation.
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**Astuce**
Lorsque vous déployez une API à l’aide de la commande `dotnet lambda deploy-serverless`, CloudFormation attribue à votre fonction Lambda un nom basé sur le nom de pile que vous avez spécifié lors du déploiement. Pour donner un nom personnalisé à votre fonction Lambda, modifiez le fichier `serverless.template` pour ajouter une propriété `FunctionName` à la ressource `AWS::Serverless::Function`. Pour en savoir plus, consultez [Type de nom](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) dans le *Guide de l’utilisateur CloudFormation*.
## Déploiement des API minimales ASP.NET sur Lambda
Pour déployer une API minimale ASP.NET sur Lambda, vous pouvez utiliser les modèles Lambda .NET pour créer un nouveau projet d’API minimale. Utilisez la commande suivante pour initialiser un nouveau projet d’API minimale. Dans cet exemple, nous nommons le projet `MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
La commande crée les fichiers et répertoires suivants dans le répertoire de votre projet.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
Le fichier `Program.cs` contient le code suivant.
```
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();
```
Pour configurer votre API minimale afin qu’elle s’exécute sur Lambda, vous devrez peut-être modifier ce code pour que les demandes et les réponses entre Lambda et ASP.NET Core soient correctement traduites. La fonction est configurée par défaut pour une source d’événements d’API REST. Pour une API HTTP ou un équilibreur de charge d’application, remplacez `(LambdaEventSource.RestApi)` par l’une des options suivantes :
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Pour déployer votre API minimale sur Lambda, exécutez les commandes suivantes pour accéder au répertoire contenant votre fichier de code source et déployer votre fonction à l’aide de CloudFormation.
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```