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.
# Tutoriel : Création et test d'une application sans serveur avec AWS Lambda
Vous pouvez créer une application Lambda sans serveur à l'aide AWS Toolkit for Visual Studio d'un modèle. Les modèles de projet Lambda incluent un modèle pour une **application AWS sans serveur**, qui est l' AWS Toolkit for Visual Studio implémentation du [modèle d'application AWS sans serveur](https://github.com/awslabs/serverless-application-model) (SAM).AWS Ce type de projet vous permet de développer un ensemble de AWS Lambda fonctions et de les déployer avec toutes les AWS ressources nécessaires en tant qu'application complète, AWS CloudFormation afin d'orchestrer le déploiement.
Pour les prérequis et les informations relatives à la configuration du AWS Toolkit for Visual Studio, consultez la section [Utilisation des modèles AWS Lambda dans AWS le Toolkit for Visual Studio](lambda-index.md).
**Topics**
+ [Création d'un nouveau projet d'application AWS sans serveur](#create-a-new-aws-serverless-application-project)
+ [Révision des fichiers de l'application sans serveur](#examine-the-files-in-the-serverless-application)
+ [Déploiement de l'application sans serveur](#deploy-the-serverless-application)
+ [Testez l'application sans serveur](#test-the-serverless-application)
## Création d'un nouveau projet d'application AWS sans serveur
AWS Les projets d'applications sans serveur créent des fonctions Lambda à l'aide d'un CloudFormation modèle sans serveur. CloudFormation les modèles vous permettent de définir des ressources supplémentaires telles que des bases de données, d'ajouter des rôles IAM et de déployer plusieurs fonctions à la fois. Cela diffère des projets AWS Lambda, qui se concentrent sur le développement et le déploiement d'une fonction Lambda unique.
La procédure suivante décrit comment créer un nouveau projet d'application AWS sans serveur.
1. Dans Visual Studio, développez le menu **Fichier**, développez **Nouveau**, puis choisissez **Projet**.
1. Dans la boîte de dialogue **Nouveau projet**, assurez-vous que les **listes déroulantes Langue**, **Plateforme** et **Type de projet** sont définies sur « Tout... » et entrez **aws lambda** dans le champ **Rechercher**.
1. Sélectionnez le modèle **AWS Serverless Application with Tests (.NET Core - C\$1).**
**Note**
Il est possible que le modèle **AWS Serverless Application with Tests (.NET Core - C\$1)** ne soit pas renseigné en haut des résultats.
1. Cliquez sur **Suivant** pour ouvrir la boîte de dialogue **Configurer votre nouveau projet**.
1. Dans la boîte de dialogue **Configurer votre nouveau projet**, saisissez **ServerlessPowertools** le **nom**, puis complétez les champs restants selon vos préférences. Cliquez sur le bouton **Créer** pour accéder à la boîte de dialogue **Sélectionner le plan**.
1. **Dans la boîte de dialogue Select Blueprint**, choisissez les **Powertools for AWS Lambda** Blueprint, puis cliquez sur **Terminer** pour créer le projet Visual Studio.
## Révision des fichiers de l'application sans serveur
Les sections suivantes fournissent un aperçu détaillé de trois fichiers d'application sans serveur créés pour votre projet :
1. serverless.template
1. Functions.cs
1. aws-lambda-tools-defaults.json
### 1. serverless.template
Un `serverless.template` fichier est un AWS CloudFormation modèle pour déclarer vos fonctions Serverless et autres AWS ressources. Le fichier inclus dans ce projet contient une déclaration pour une seule fonction Lambda qui sera exposée via Amazon API Gateway en tant `HTTP *Get*` qu'opération. Vous pouvez modifier ce modèle pour personnaliser la fonction existante ou ajouter d'autres fonctions et autres ressources requises par votre application.
Voici un exemple de fichier `serverless.template` :
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Transform": "AWS::Serverless-2016-10-31",
"Description": "An AWS Serverless Application.",
"Resources": {
"Get": {
"Type": "AWS::Serverless::Function",
"Properties": {
"Architectures": [
"x86_64"
],
"Handler": "ServerlessPowertools::ServerlessPowertools.Functions::Get",
"Runtime": "dotnet8",
"CodeUri": "",
"MemorySize": 512,
"Timeout": 30,
"Role": null,
"Policies": [
"AWSLambdaBasicExecutionRole"
],
"Environment": {
"Variables": {
"POWERTOOLS_SERVICE_NAME": "ServerlessGreeting",
"POWERTOOLS_LOG_LEVEL": "Info",
"POWERTOOLS_LOGGER_CASE": "PascalCase",
"POWERTOOLS_TRACER_CAPTURE_RESPONSE": true,
"POWERTOOLS_TRACER_CAPTURE_ERROR": true,
"POWERTOOLS_METRICS_NAMESPACE": "ServerlessGreeting"
}
},
"Events": {
"RootGet": {
"Type": "Api",
"Properties": {
"Path": "/",
"Method": "GET"
}
}
}
}
}
},
"Outputs": {
"ApiURL": {
"Description": "API endpoint URL for Prod environment",
"Value": {
"Fn::Sub": "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
}
}
}
}
```
Notez que de nombreux champs de `...AWS:: Serverless::Function...` déclaration sont similaires aux champs d'un déploiement de projet Lambda. La journalisation, les métriques et le suivi de Powertools sont configurés via les variables d'environnement suivantes :
+ POWERTOOLS\$1SERVICE\$1NAME= ServerlessGreeting
+ PowerTools\$1Log\$1Level=Informations
+ POWERTOOLS\$1LOGGER\$1CASE= PascalCase
+ PowerTools\$1Tracer\$1Capture\$1Response=vrai
+ PowerTools\$1Tracer\$1Capture\$1Error=vrai
+ ESPACE DE NOMS POWERTOOLS\$1METRICS\$1= ServerlessGreeting
Pour obtenir des définitions et des informations supplémentaires sur les variables d'environnement, consultez le site Web [Powertools for AWS Lambda references](https://awslabs.github.io/aws-lambda-powertools-dotnet/references/).
### 2. Functions.cs
`Functions.cs`est un fichier de classe contenant une méthode C\$1 mappée à une seule fonction déclarée dans le fichier modèle. La fonction Lambda répond aux `HTTP Get` méthodes d'API Gateway. Voici un exemple de `Functions.cs` fichier :
```
public class Functions
{
[Logging(LogEvent = true, CorrelationIdPath = CorrelationIdPaths.ApiGatewayRest)]
[Metrics(CaptureColdStart = true)]
[Tracing(CaptureMode = TracingCaptureMode.ResponseAndError)]
public APIGatewayProxyResponse Get(APIGatewayProxyRequest request, ILambdaContext context)
{
Logger.LogInformation("Get Request");
var greeting = GetGreeting();
var response = new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = greeting,
Headers = new Dictionary (string, string) { { "Content-Type", "text/plain" } }
};
return response;
}
[Tracing(SegmentName = "GetGreeting Method")]
private static string GetGreeting()
{
Metrics.AddMetric("GetGreeting_Invocations", 1, MetricUnit.Count);
return "Hello Powertools for AWS Lambda (.NET)";
}
}
```
### 3. aws-lambda-tools-defaults.json
`aws-lambda-tools-defaults.json`fournit les valeurs par défaut pour l'assistant de AWS déploiement dans Visual Studio et les AWS Lambda commandes ajoutées à la CLI .NET Core. Voici un exemple du `aws-lambda-tools-defaults.json` fichier inclus dans ce projet :
```
{
"profile": "Default",
"region": "us-east-1",
"configuration": "Release",
"s3-prefix": "ServerlessPowertools/",
"template": "serverless.template",
"template-parameters": ""
}
```
## Déploiement de l'application sans serveur
Pour déployer votre application sans serveur, procédez comme suit :
1. Dans l'**explorateur de solutions**, ouvrez le menu contextuel de votre projet (cliquez avec le bouton droit de la souris) et choisissez **Publier sur AWS Lambda pour** ouvrir la boîte de dialogue **Publier une application AWS sans serveur**.
1. Dans la boîte de dialogue **Publier une application AWS sans serveur**, entrez le nom du conteneur de CloudFormation pile dans le champ **Stack Name**.
1. Dans le champ **Compartiment S3**, choisissez un compartiment Amazon S3 vers lequel votre bundle d'applications sera chargé ou choisissez le **Nouveau...** bouton et entrez le nom d'un nouveau compartiment Amazon S3. Choisissez ensuite **Publier** pour publier afin de déployer votre application.
**Note**
Votre CloudFormation stack et votre compartiment Amazon S3 doivent se trouver dans la même AWS région. Les autres paramètres de votre projet sont définis dans le `serverless.template` fichier.
![\[Image de la boîte de dialogue Publier une application AWS sans serveur.\]](http://docs.aws.amazon.com/fr_fr/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-serverless-03192024.png)
1. La fenêtre **Stack** View s'ouvre pendant le processus de publication. Lorsque le déploiement est terminé, le champ **État** affiche :`CREATE_COMPLETE`.
![\[Image de la fenêtre d'affichage de la pile de déploiement dans Visual Studio.\]](http://docs.aws.amazon.com/fr_fr/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-stackview-03192024.png)
## Testez l'application sans serveur
Lorsque la création de la pile est terminée, vous pouvez consulter votre application à l'aide de l'**URL AWS sans serveur**. Si vous avez terminé ce didacticiel sans ajouter de fonctions ou de paramètres supplémentaires, l'accès à votre URL AWS sans serveur affiche la phrase suivante dans votre navigateur Web :`Hello Powertools for AWS Lambda (.NET)`.