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.

# Création de fonctions d'événement .NET Lambda avec une compilation AOT native dans AWS SAM
<a name="build-dotnet7"></a>

Créez et empaquetez vos fonctions AWS Lambda événementielles .NET 8 avec le AWS Serverless Application Model (AWS SAM), en utilisant la compilation native Ahead-of-Time (AOT) pour améliorer les temps de démarrage à AWS Lambda froid.

**Topics**
+ [Présentation de .NET 8 Native AOT](#build-dotnet7-overview)
+ [Utilisation AWS SAM avec vos fonctions d'événements Lambda .NET 8](#build-dotnet7-sam)
+ [Installer les prérequis](#build-dotnet7-prerequisites)
+ [Définissez les fonctions d'événement Lambda .NET 8 dans votre AWS SAM modèle](#build-dotnet7-sam-define)
+ [Créer votre application à l'aide de la   AWS SAM INTERFACE DE LIGNE DE COMMANDE (CLI)](#build-dotnet7-sam-build)
+ [En savoir plus](#build-dotnet7-learn-more)

## Présentation de .NET 8 Native AOT
<a name="build-dotnet7-overview"></a>

Historiquement, les fonctions Lambda .NET ont eu des temps de démarrage à froid affectant l'expérience utilisateur, la latence du système et les coûts d'utilisation de vos applications sans serveur. Avec la compilation .NET Native AOT, vous pouvez améliorer les temps de démarrage à froid de vos fonctions Lambda. Pour en savoir plus sur l'AOT natif pour .NET 8, consultez la section [Utilisation de l'AOT natif](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) dans le référentiel * GitHub Dotnet*.

## Utilisation AWS SAM avec vos fonctions d'événements Lambda .NET 8
<a name="build-dotnet7-sam"></a>

Procédez comme suit pour configurer vos fonctions Lambda .NET 8 avec le AWS Serverless Application Model ()AWS SAM :
+ Installez les prérequis sur votre machine de développement.
+ Définissez les fonctions Lambda .NET 8 dans votre AWS SAM modèle.
+ Créez votre application à l'aide du AWS SAMCLI.

## Installer les prérequis
<a name="build-dotnet7-prerequisites"></a>

Les prérequis sont les suivants :
+ Le AWS SAMCLI
+ La CLI .NET Core
+ L'outil global Amazon.Lambda.Tools .NET Core
+ Docker

**Installer la   AWS SAM INTERFACE DE LIGNE DE COMMANDE (CLI)**

1. Pour vérifier si la CLI  AWS SAM est déjà installée, procédez comme suit :

   ```
   sam --version
   ```

1. Pour installer le AWS SAMCLI, voir[Installer la CLI  AWS SAM](install-sam-cli.md).

1. Pour mettre à niveau une version installée du AWS SAMCLI, voir[Mise à niveau de la CLI  AWS SAM en cours](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).

**Installer la CLI .NET Core**

1. Pour télécharger et installer la CLI .NET Core, veuillez consulter la rubrique [Télécharger .NET](https://dotnet.microsoft.com/download) (langue française non garantie) du site web Microsoft.

1. Pour plus d'informations sur la CLI .NET Core, veuillez consulter la rubrique [Interface de ligne de commande .NET Core](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) dans le *Guide du développeur AWS Lambda *.

**Installation de l'outil global Amazon.Lambda.Tools .NET Core**

1. Exécutez la commande suivante :

   ```
   dotnet tool install -g Amazon.Lambda.Tools
   ```

1. Si cet outil est déjà installé, vous pouvez vérifier qu'il s'agit de la dernière version avec la commande suivante :

   ```
   dotnet tool update -g Amazon.Lambda.Tools
   ```

1. Pour plus d'informations sur l'outil global Amazon.Lambda.Tools .NET Core, consultez le référentiel [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) sur GitHub.

**Installation Docker**
+ Docker doit être installé pour permettre la création avec la compilation anticipée native. Pour obtenir des instructions d’installation, consultez [Installation de Docker pour une utilisation avec la   AWS SAM INTERFACE DE LIGNE DE COMMANDE (CLI)](install-docker.md).

## Définissez les fonctions d'événement Lambda .NET 8 dans votre AWS SAM modèle
<a name="build-dotnet7-sam-define"></a>

Pour définir une fonction Lambda .NET8 dans votre AWS SAM modèle, procédez comme suit :

1. Exécutez la commande suivante depuis le répertoire de départ de votre choix :

   ```
   sam init
   ```

1. Sélectionnez `AWS Quick Start Templates` pour choisir un modèle de départ.

1. Choisissez le modèle `Hello World Example`.

1. Choisissez de ne pas utiliser le moteur d'exécution et le type de package les plus populaires en saisissant`n`.

1. Pour l'exécution, choisissez`dotnet8`.

1. Pour le type de package, choisissez`Zip`.

1. Pour votre modèle de démarrage, choisissez`Hello World Example using native AOT`.

**Installation Docker**
+ Docker doit être installé pour permettre la création avec la compilation anticipée native. Pour obtenir des instructions d’installation, consultez [Installation de Docker pour une utilisation avec la   AWS SAM INTERFACE DE LIGNE DE COMMANDE (CLI)](install-docker.md).

```
Resources:
HelloWorldFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: ./src/HelloWorldAot/
    Handler: bootstrap
    Runtime: dotnet8
    Architectures:
      - x86_64
    Events:
      HelloWorldAot:
        Type: Api 
        Properties:
          Path: /hello
          Method: get
```

**Note**  
Lorsque la `Event` propriété de an `AWS::Serverless::Function` est définie sur`Api`, mais que la `RestApiId` propriété n'est pas spécifiée, AWS SAM la `AWS::ApiGateway::RestApi` CloudFormation ressource est générée.

## Créer votre application à l'aide de la   AWS SAM INTERFACE DE LIGNE DE COMMANDE (CLI)
<a name="build-dotnet7-sam-build"></a>

 Depuis le répertoire racine de votre projet, exécutez la `sam build` commande pour commencer à créer votre application. Si la `PublishAot` propriété a été définie dans votre fichier de projet .NET 8, elle AWS SAMCLI sera compilée avec la compilation native AOT. Pour en savoir plus sur la propriété `PublishAot`, veuillez consulter la rubrique [Déploiement anticipé natif](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) (langue française non garantie) dans la *documentation .NET* de Microsoft.

Pour créer votre fonction, AWS SAMCLI invoque la CLI .NET Core qui utilise l'outil global Amazon.Lambda.Tools .NET Core.

**Note**  
Lors de la création, si un fichier `.sln` existe dans le même répertoire ou dans le répertoire parent de votre projet, le répertoire contenant le fichier `.sln` sera monté dans le conteneur. Si aucun fichier `.sln` n'est trouvé, seul le dossier du projet est monté. Par conséquent, si vous créez une application multi-projets, assurez-vous que le fichier `.sln` est bien localisé.

## En savoir plus
<a name="build-dotnet7-learn-more"></a>

Pour plus d'informations sur la création de fonctions Lambda .NET 8, consultez [Présentation du moteur d'exécution .NET 8](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/) pour. AWS Lambda

Pour obtenir la référence de la commande **sam build**, consultez [création sam](sam-cli-command-reference-sam-build.md).