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.
# Tutorial: Erstellen und Testen einer serverlosen Anwendung mit AWS Lambda
Sie können mithilfe einer Vorlage eine serverlose Lambda-Anwendung erstellen AWS Toolkit for Visual Studio . Zu den Lambda-Projektvorlagen gehört eine Vorlage für eine **AWS serverlose Anwendung**, bei der es sich um die AWS Toolkit for Visual Studio Implementierung des [AWS Serverless Application Model (AWS](https://github.com/awslabs/serverless-application-model)SAM) handelt. Mit diesem Projekttyp können Sie eine Sammlung von AWS Lambda Funktionen entwickeln und diese mit allen erforderlichen AWS Ressourcen als gesamte Anwendung bereitstellen, um die Bereitstellung AWS CloudFormation zu orchestrieren.
Voraussetzungen und Informationen zur Einrichtung von finden Sie unter [Verwenden der AWS Lambda-Vorlagen im AWS Toolkit for Visual Studio](lambda-index.md). AWS Toolkit for Visual Studio
**Topics**
+ [Erstellen Sie ein neues AWS serverloses Anwendungsprojekt](#create-a-new-aws-serverless-application-project)
+ [Überprüfen der Dateien der serverlosen Anwendung](#examine-the-files-in-the-serverless-application)
+ [Bereitstellen der serverlosen Anwendung](#deploy-the-serverless-application)
+ [Testen der serverlosen Anwendung](#test-the-serverless-application)
## Erstellen Sie ein neues AWS serverloses Anwendungsprojekt
AWS Serverlose Anwendungsprojekte erstellen Lambda-Funktionen mit einer CloudFormation serverlosen Vorlage. CloudFormation Mithilfe von Vorlagen können Sie zusätzliche Ressourcen wie Datenbanken definieren, IAM-Rollen hinzufügen und mehrere Funktionen gleichzeitig bereitstellen. Dies unterscheidet sich von AWS Lambda-Projekten, die sich auf die Entwicklung und Bereitstellung einer einzigen Lambda-Funktion konzentrieren.
Das folgende Verfahren beschreibt, wie Sie ein neues Projekt für AWS serverlose Anwendungen erstellen.
1. Erweitern Sie in Visual Studio das Menü **Datei**, erweitern Sie **Neu** und wählen Sie dann **Projekt** aus.
1. Stellen Sie im Dialogfeld „**Neues Projekt**“ sicher, dass die Dropdown-Felder **Sprache**, **Plattform** und **Projekttyp** auf „Alle...“ gesetzt sind, und geben Sie **aws lambda** in das **Suchfeld** ein.
1. Wählen Sie die **AWS Vorlage Serverlose Anwendung mit Tests (.NET Core — C\$1)** aus.
**Anmerkung**
Es ist möglich, dass die Vorlage **AWS Serverlose Anwendung mit Tests (.NET Core — C\$1)** nicht ganz oben in den Ergebnissen angezeigt wird.
1. Klicken Sie auf **Weiter**, um das Dialogfeld **Neues Projekt konfigurieren zu** öffnen.
1. Geben ****ServerlessPowertools**Sie im Dialogfeld „Neues Projekt konfigurieren**“ den **Namen** ein und füllen Sie dann die verbleibenden Felder nach Ihren Wünschen aus. Wählen Sie die Schaltfläche „**Erstellen**“, um mit dem Dialogfeld **„Blueprint auswählen**“ fortzufahren.
1. **Wählen Sie im Dialogfeld „Blueprint auswählen**“ die Option „**Powertools for AWS Lambda** Blueprint“ und anschließend „**Fertig stellen“, um das Visual Studio-Projekt** zu erstellen.
## Überprüfen der Dateien der serverlosen Anwendung
Die folgenden Abschnitte bieten einen detaillierten Überblick über drei Dateien für serverlose Anwendungen, die für Ihr Projekt erstellt wurden:
1. serverless.template
1. Functions.cs
1. aws-lambda-tools-defaults.json
### 1. serverlose Vorlage
Eine `serverless.template` Datei ist eine AWS CloudFormation Vorlage für die Deklaration Ihrer serverlosen Funktionen und anderer Ressourcen. AWS Die in diesem Projekt enthaltene Datei enthält eine Deklaration für eine einzelne Lambda-Funktion, die über das Amazon API Gateway als `HTTP *Get*` Operation verfügbar gemacht wird. Sie können diese Vorlage bearbeiten, um die bestehende Funktion anzupassen oder weitere Funktionen und andere Ressourcen hinzuzufügen, die für Ihre Anwendung erforderlich sind.
Im Folgenden wird ein Beispiel für eine `serverless.template`-Datei dargestellt:
```
{
"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/"
}
}
}
}
```
Beachten Sie, dass viele der `...AWS:: Serverless::Function...` Deklarationsfelder den Feldern einer Lambda-Projektbereitstellung ähneln. Powertools Logging, Metrics und Tracing werden über die folgenden Umgebungsvariablen konfiguriert:
+ POWERTOOLS\$1SERVICE\$1NAME= ServerlessGreeting
+ POWERTOOLS\$1LOG\$1LEVEL=Informationen
+ POWERTOOLS\$1LOGGER\$1CASE= PascalCase
+ PowerTools\$1Tracer\$1Capture\$1Response=Wahr
+ PowerTools\$1Tracer\$1Capture\$1Error=Wahr
+ POWERTOOLS\$1METRICS\$1NAMESPACE= ServerlessGreeting
[Definitionen und zusätzliche Informationen zu den Umgebungsvariablen finden Sie auf der Powertools-Website für Referenzen. AWS Lambda](https://awslabs.github.io/aws-lambda-powertools-dotnet/references/)
### 2. Functions.cs
`Functions.cs`ist eine Klassendatei, die eine C\$1-Methode enthält, die einer einzelnen Funktion zugeordnet ist, die in der Vorlagendatei deklariert ist. Die Lambda-Funktion reagiert auf `HTTP Get` Methoden von API Gateway. Das Folgende ist ein Beispiel für die `Functions.cs` Datei:
```
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`stellt die Standardwerte für den AWS Bereitstellungsassistenten in Visual Studio und die AWS Lambda Befehle bereit, die zur.NET Core CLI hinzugefügt wurden. Im Folgenden finden Sie ein Beispiel für die `aws-lambda-tools-defaults.json` Datei, die in diesem Projekt enthalten ist:
```
{
"profile": "Default",
"region": "us-east-1",
"configuration": "Release",
"s3-prefix": "ServerlessPowertools/",
"template": "serverless.template",
"template-parameters": ""
}
```
## Bereitstellen der serverlosen Anwendung
Gehen Sie wie folgt vor, um Ihre serverlose Anwendung bereitzustellen
1. Öffnen Sie im **Solution Explorer** das Kontextmenü für Ihr Projekt (Rechtsklick) und wählen Sie In ** AWS Lambda veröffentlichen, um** das Dialogfeld ** AWS Serverlose Anwendung veröffentlichen** zu öffnen.
1. **Geben Sie im Dialogfeld ** AWS Serverlose Anwendung veröffentlichen** im Feld Stackname einen Namen für den CloudFormation Stack-Container ein.**
1. Wählen Sie im Feld **S3-Bucket** einen Amazon S3 S3-Bucket aus, in den Ihr Anwendungspaket hochgeladen werden soll, oder wählen Sie **New...** klicken Sie und geben Sie den Namen eines neuen Amazon S3 S3-Buckets ein. Wählen Sie dann **Publish to Publish** (Veröffentlichen), um Ihre Anwendung bereitzustellen.
**Anmerkung**
Ihr CloudFormation Stack und Ihr Amazon S3 S3-Bucket müssen in derselben AWS Region existieren. Die übrigen Einstellungen für Ihr Projekt sind in der `serverless.template` Datei definiert.
![\[Bild des Dialogfelds „ AWS Serverlose Anwendung veröffentlichen“.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-serverless-03192024.png)
1. Das **Stack-Ansichtsfenster** wird während des Veröffentlichungsvorgangs geöffnet. Wenn die Bereitstellung abgeschlossen ist, wird im Feld **Status** Folgendes angezeigt:`CREATE_COMPLETE`.
![\[Bild des Fensters mit der Ansicht des Bereitstellungsstapels in Visual Studio.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-stackview-03192024.png)
## Testen der serverlosen Anwendung
Wenn die Erstellung des Stacks abgeschlossen ist, können Sie Ihre Anwendung mithilfe der **AWS serverlosen URL** anzeigen. Wenn Sie dieses Tutorial abgeschlossen haben, ohne zusätzliche Funktionen oder Parameter hinzuzufügen, wird beim Zugriff auf Ihre AWS serverlose URL der folgende Satz in Ihrem Webbrowser angezeigt:. `Hello Powertools for AWS Lambda (.NET)`