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. # AWS Lambda Entwickeln und implementieren Sie Ihre .NET Core-basierten C\$1-Lambda-Funktionen mit dem. AWS Toolkit for Visual Studio AWS Lambda ist ein Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Das Toolkit for Visual Studio AWS Lambda enthält.NET Core-Projektvorlagen für Visual Studio. Weitere Informationen AWS Lambda dazu finden Sie im [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) Developer Guide. Weitere Informationen zu.NET Core finden Sie im [Microsoft.NET Core-Handbuch](https://docs.microsoft.com/en-us/dotnet/articles/core/). Weitere Informationen zu .NET Core-Voraussetzungen und Installationsanweisungen für Windows-, macOS- und Linux-Plattformen finden Sie unter [.NET Core Downloads](https://www.microsoft.com/net/download/core). In den folgenden Themen wird beschrieben, wie AWS Lambda Sie mit dem Toolkit for Visual Studio arbeiten. **Topics** + [Grundlegendes AWS Lambda Projekt](lambda-creating-project-in-visual-studio.md) + [AWS Lambda Basisprojekt: Docker-Image erstellen](lambda-creating-project-docker-image.md) + [Tutorial: Erstellen und Testen einer serverlosen Anwendung mit AWS Lambda](lambda-build-test-severless-app.md) + [Tutorial: Erstellen einer Amazon Rekognition-Lambda-Anwendung](lambda-rekognition-example.md) + [Tutorial: Verwenden von Amazon Logging Frameworks mit AWS Lambda zum Erstellen von Anwendungsprotokollen](cw-log-frameworks.md) # Grundlegendes AWS Lambda Projekt Sie können eine Lambda-Funktion mithilfe von Microsoft.NET Core-Projektvorlagen erstellen, in der AWS Toolkit for Visual Studio. ## Erstellen Sie ein Visual Studio-.NET-Core-Lambda-Projekt Sie können Lambda-Visual Studio-Vorlagen und -Blueprints verwenden, um Ihre Projektinitialisierung zu beschleunigen. Lambda-Blueprints enthalten vorgefertigte Funktionen, die die Erstellung einer flexiblen Projektgrundlage vereinfachen. **Anmerkung** Der Lambda-Dienst hat Datenbeschränkungen für verschiedene Pakettypen. Ausführliche Informationen zu Datenlimits finden Sie unter dem Thema [Lambda-Kontingente](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) im *AWS Lambda-Benutzerhandbuch*. **So erstellen Sie ein Lambda-Projekt in Visual Studio** 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**“ die Dropdown-Felder **Sprache**, **Plattform** und **Projekttyp** auf „Alle“ ein und geben Sie dann **aws lambda** in das **Suchfeld** ein. Wählen Sie die **AWS Vorlage Lambda Project (.NET Core — C\$1).** 1. Geben **AWSLambdaSample** Sie im Feld **Name** den gewünschten **Speicherort** für die Datei ein und wählen Sie dann **Erstellen**, um fortzufahren. 1. **Wählen Sie auf der Seite „Blueprint** auswählen“ den Blueprint „**Leere Funktion**“ und anschließend „**Fertig stellen**“ aus, um das Visual Studio-Projekt zu erstellen. ## Überprüfen der Projektdateien Es gibt zwei Projektdateien, die überprüft werden müssen: `aws-lambda-tools-defaults.json` und. `Function.cs` Das folgende Beispiel zeigt die `aws-lambda-tools-defaults.json` Datei, die automatisch als Teil Ihres Projekts erstellt wird. Mithilfe der Felder in dieser Datei können Sie Build-Optionen festlegen. **Anmerkung** Die Projektvorlagen in Visual Studio enthalten viele verschiedene Felder. Beachten Sie Folgendes: **Funktionshandler**: gibt die Methode an, die ausgeführt wird, wenn die Lambda-Funktion ausgeführt wird Wenn Sie einen Wert im **Function-Handler-Feld** angeben, wird dieser Wert im Veröffentlichungsassistenten automatisch aufgefüllt. Wenn Sie die Funktion, Klasse oder Assembly umbenennen, müssen Sie auch das entsprechende Feld in der Datei aktualisieren. `aws-lambda-tools-defaults.json` ``` { "Information": [ "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.", "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.", "dotnet lambda help", "All the command line options for the Lambda command can be specified in this file." ], "profile": "default", "region": "us-west-2", "configuration": "Release", "function-architecture": "x86_64", "function-runtime": "dotnet8", "function-memory-size": 512, "function-timeout": 30, "function-handler": "AWSLambdaSample::AWSLambdaSample.Function::FunctionHandler" } ``` Untersuchen Sie die `Function.cs` Datei. `Function.cs`definiert die C\$1-Funktionen, die als Lambda-Funktionen verfügbar gemacht werden sollen. Dies `FunctionHandler` ist die Lambda-Funktionalität, die ausgeführt wird, wenn die Lambda-Funktion ausgeführt wird. In diesem Projekt ist eine Funktion definiert:`FunctionHandler`, die den Eingabetext `ToUpper()` aufruft. Ihr Projekt ist jetzt bereit, auf Lambda veröffentlicht zu werden. ## Auf Lambda veröffentlichen Das folgende Verfahren und das folgende Bild zeigen, wie Sie Ihre Funktion mit dem AWS Toolkit for Visual Studio auf Lambda hochladen. ![\[Aufrufen der Seite für den Funktionstest\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/uploadnet8.png) **Veröffentlichen Sie Ihre Funktion auf Lambda** 1. Navigieren Sie zum AWS Explorer, indem Sie **View** erweitern und **AWS Explorer** auswählen. 1. Öffnen Sie im **Solution Explorer** das Kontextmenü für das Projekt, das Sie veröffentlichen möchten (klicken Sie mit der rechten Maustaste darauf), und wählen Sie dann In ** AWS Lambda veröffentlichen**, um das Fenster **Lambda-Funktion hochladen** zu öffnen. 1. Füllen **Sie im Fenster Lambda-Funktion hochladen** die folgenden Felder aus: 1. **Pakettyp**: Wählen Sie**Zip**. Als Ergebnis des Build-Prozesses wird eine ZIP-Datei erstellt und auf Lambda hochgeladen. Alternativ können Sie den **Pakettyp** wählen**Image**. Das [Tutorial: Basic Lambda Project Creating Docker Image](lambda-creating-project-docker-image.md) beschreibt, wie Sie mit **Package** Type veröffentlichen. **Image** 1. **Lambda Runtime**: Wählen Sie Ihre Lambda Runtime aus dem Drop-down-Menü aus. 1. **Architektur**: Wählen Sie die radiale Architektur für Ihre bevorzugte Architektur aus. 1. **Funktionsname**: Wählen Sie das Radial für **Neue Funktion erstellen** aus und geben Sie dann einen Anzeigenamen für Ihre Lambda-Instanz ein. Auf diesen Namen wird sowohl vom AWS Explorer als auch von AWS-Managementkonsole Displays verwiesen. 1. **Handler**: Verwenden Sie dieses Feld, um einen Funktionshandler anzugeben. Beispiel: **AWSLambdaSample::AWSLambdaSample.Function::FunctionHandler**. 1. *(Optional)* **Beschreibung**: Geben Sie beschreibenden Text ein, der zusammen mit Ihrer Instanz angezeigt werden soll, und zwar aus dem AWS-Managementkonsole. 1. **Konfiguration**: Wählen Sie Ihre bevorzugte Konfiguration aus dem Drop-down-Menü aus. 1. **Framework**: Wählen Sie Ihr bevorzugtes Framework aus dem Drop-down-Menü aus. 1. **Einstellungen speichern**: Wählen Sie dieses Feld, um Ihre aktuellen Einstellungen `aws-lambda-tools-defaults.json` als Standard für future Bereitstellungen zu speichern. 1. Wählen Sie **Weiter**, um zum Fenster mit den **erweiterten Funktionsdetails** zu gelangen. 1. Füllen Sie im Fenster „**Erweiterte Funktionsdetails**“ die folgenden Felder aus: 1. **Rollenname**: Wählen Sie eine Rolle aus, die Ihrem Konto zugeordnet ist. Die Rolle stellt temporäre Anmeldeinformationen für alle AWS Serviceanfragen bereit, die über den Code in der Funktion getätigt werden. Wenn Sie keine Rolle haben, scrollen Sie in der Dropdownauswahl zu **Neue Rolle basierend auf AWS verwalteter Richtlinie** und wählen Sie dann aus **AWSLambdaBasicExecutionRole**. Diese Rolle hat nur minimale Zugriffsberechtigungen. **Anmerkung** Ihr Konto muss berechtigt sein, die ListPolicies IAM-Aktion auszuführen. Andernfalls ist die Liste mit den **Rollennamen** leer und Sie können den Vorgang nicht fortsetzen. 1. *(Optional)* Wenn Ihre Lambda-Funktion auf Ressourcen in einer Amazon VPC zugreift, wählen Sie die Subnetze und Sicherheitsgruppen aus. 1. *(Optional)* Legen Sie alle Umgebungsvariablen fest, die Ihre Lambda-Funktion benötigt. Die Schlüssel werden automatisch mit dem kostenlosen Standard-Serviceschlüssel verschlüsselt. Alternativ können Sie einen AWS KMS Schlüssel angeben, für den eine Gebühr anfällt. [KMS](https://aws.amazon.com/kms/) ist ein verwalteter Service, mit dem Sie Schlüssel zum Verschlüsseln Ihrer Daten erstellen und steuern können. Wenn Sie einen AWS KMS Schlüssel haben, können Sie ihn aus der Liste auswählen. 1. Wählen Sie **Hochladen**, um das Fenster mit der **Upload-Funktion** zu öffnen und den Upload-Vorgang zu starten. **Anmerkung** Die Seite mit den **Upload-Funktionen** wird angezeigt, während die Funktion in hochgeladen wird. AWS Um den Assistenten nach dem Hochladen geöffnet zu lassen, sodass Sie den Bericht ansehen können, deaktivieren Sie unten im Formular die **Option Assistent bei erfolgreichem Abschluss automatisch schließen**, bevor der Upload abgeschlossen ist. Nachdem die Funktion hochgeladen wurde, ist Ihre Lambda-Funktion live. Die Seite **Funktion:** Ansicht wird geöffnet und zeigt die Konfiguration Ihrer neuen Lambda-Funktion an. 1. Geben Sie auf der Registerkarte **Testfunktion** `hello lambda!` in das Texteingabefeld ein und wählen Sie dann **Invoke**, um Ihre Lambda-Funktion manuell aufzurufen. Ihr Text erscheint auf der Registerkarte „**Antwort**“ und wurde in Großbuchstaben umgewandelt. **Anmerkung** Sie können die Ansicht **Function:** jederzeit erneut öffnen, indem Sie im **AWS Explorer** unter dem Knoten auf Ihre bereitgestellte Instanz doppelklicken. **AWS Lambda** ![\[Aufrufen der Seite für den Funktionstest\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/invokeBasic.PNG) 1. *(Optional)* Um zu bestätigen, dass Sie Ihre Lambda-Funktion erfolgreich veröffentlicht haben, melden Sie sich bei der an AWS-Managementkonsole und wählen Sie dann Lambda aus. In der Konsole werden alle Ihre veröffentlichten Lambda-Funktionen angezeigt, einschließlich der soeben erstellten. ## Aufräumen Wenn Sie mit diesem Beispiel nicht weiterentwickeln möchten, löschen Sie die von Ihnen bereitgestellte Funktion, damit Ihnen nicht genutzte Ressourcen in Ihrem Konto nicht in Rechnung gestellt werden. **Anmerkung** Lambda überwacht Lambda-Funktionen automatisch für Sie und meldet Metriken über Amazon. CloudWatch Informationen zur Überwachung und Problembehebung Ihrer Funktion finden Sie im CloudWatch Thema [Troubleshooting and Monitoring AWS Lambda Functions with Amazon](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-functions.html) im AWS Lambda Developer Guide. **Um Ihre Funktion zu löschen** 1. Erweitern Sie im **AWS Explorer** den **AWS Lambda**Knoten. 1. Klicken Sie mit der rechten Maustaste auf Ihre bereitgestellte Instanz und wählen Sie dann **Löschen**. # AWS Lambda Basisprojekt: Docker-Image erstellen Sie können das Toolkit for Visual Studio verwenden, um Ihre AWS Lambda Funktion als Docker-Image bereitzustellen. Mit Docker haben Sie mehr Kontrolle über Ihre Laufzeit. Sie können beispielsweise benutzerdefinierte Laufzeiten wie .NET 8.0 wählen. Sie stellen Ihr Docker-Image auf die gleiche Weise bereit wie jedes andere Container-Image. Dieses Tutorial ist [Tutorial: Basic Lambda Project](lambda-creating-project-in-visual-studio.md) sehr ähnlich, mit zwei Unterschieden: + Ein Dockerfile ist im Projekt enthalten. + Eine alternative Veröffentlichungskonfiguration wird ausgewählt. Informationen zu Lambda-Container-Images finden Sie unter [Lambda Deployment Packages](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) im *AWS Lambda Developer* Guide. Weitere Informationen zur Arbeit mit Lambda AWS Toolkit for Visual Studio finden Sie im AWS Toolkit for Visual Studio Thema [Verwenden der AWS Lambda Vorlagen in](lambda-index.md) diesem Benutzerhandbuch. ## Erstellen Sie ein Visual Studio-.NET-Core-Lambda-Projekt Sie können Lambda Visual Studio-Vorlagen und -Blueprints verwenden, um Ihre Projektinitialisierung zu beschleunigen. Lambda-Blueprints enthalten vorgefertigte Funktionen, die die Erstellung einer flexiblen Projektgrundlage vereinfachen. **So erstellen Sie ein Visual Studio-.NET Core Lambda-Projekt** 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**“ die Dropdown-Felder **Sprache**, **Plattform** und **Projekttyp** auf „Alle“ ein und geben Sie dann **aws lambda** in das **Suchfeld** ein. Wählen Sie die **AWS Vorlage Lambda Project (.NET Core — C\$1).** 1. **Geben Sie **AWSLambdaDocker** im Feld **Projektname** den **Speicherort** Ihrer Datei ein und wählen Sie dann Erstellen aus.** 1. **Wählen Sie auf der Seite „Blueprint** auswählen“ den Blueprint **.NET 8 (Container Image)** aus, und klicken Sie dann auf **Fertig stellen**, um das Visual Studio-Projekt zu erstellen. Sie können jetzt die Struktur und den Code des Projekts überprüfen. ## Projektdateien überprüfen In den folgenden Abschnitten werden die drei Projektdateien untersucht, die mit **dem.NET 8-Blueprint (Container Image)** erstellt wurden: 1. `Dockerfile` 1. `aws-lambda-tools-defaults.json` 1. `Function.cs` ### 1. Dockerfile A `Dockerfile` führt drei Hauptaktionen aus: + `FROM`: Legt das Basis-Image fest, das für dieses Image verwendet werden soll. Dieses Basisimage stellt .NET Runtime, Lambda Runtime und ein Shell-Skript bereit, das einen Einstiegspunkt für den Lambda.NET-Prozess bereitstellt. + `WORKDIR`: Legt das interne Arbeitsverzeichnis des Images fest als. `/var/task` + `COPY`: Kopiert die während des Build-Prozesses generierten Dateien von ihrem lokalen Speicherort in das Arbeitsverzeichnis des Images. Die folgenden optionalen `Dockerfile` Aktionen können Sie angeben: + `ENTRYPOINT`: Das Basis-Image enthält bereits ein. Dabei handelt es sich um den Startvorgang`ENTRYPOINT`, der ausgeführt wird, wenn das Image gestartet wird. Wenn Sie Ihren eigenen angeben möchten, überschreiben Sie diesen Basiseinstiegspunkt. + `CMD`: Gibt an, AWS welchen benutzerdefinierten Code Sie ausführen möchten. Es erwartet einen vollständig qualifizierten Namen für Ihre benutzerdefinierte Methode. Diese Zeile muss entweder direkt in das Dockerfile aufgenommen werden oder kann während des Veröffentlichungsvorgangs angegeben werden. ``` # Example of alternative way to specify the Lambda target method rather than during the publish process. CMD [ "AWSLambdaDocker::AWSLambdaDocker.Function::FunctionHandler"] ``` Das Folgende ist ein Beispiel für ein Dockerfile, das mit dem.NET 8-Blueprint (Container Image) erstellt wurde. ``` FROM public.ecr.aws/lambda/dotnet:8 WORKDIR /var/task # This COPY command copies the .NET Lambda project's build artifacts from the host machine into the image. # The source of the COPY should match where the .NET Lambda project publishes its build artifacts. If the Lambda function is being built # with the AWS .NET Lambda Tooling, the `--docker-host-build-output-dir` switch controls where the .NET Lambda project # will be built. The .NET Lambda project templates default to having `--docker-host-build-output-dir` # set in the aws-lambda-tools-defaults.json file to "bin/Release/lambda-publish". # # Alternatively Docker multi-stage build could be used to build the .NET Lambda project inside the image. # For more information on this approach checkout the project's README.md file. COPY "bin/Release/lambda-publish" . ``` ### 2. aws-lambda-tools-defaults.json Die `aws-lambda-tools-defaults.json` Datei wird verwendet, um Standardwerte für den Toolkit for Visual Studio Studio-Bereitstellungsassistenten und .NET Core CLI anzugeben. In der folgenden Liste werden Felder beschrieben, die Sie in Ihrer `aws-lambda-tools-defaults.json` Datei festlegen können. + `profile`: legt Ihr AWS Profil fest. + `region`: legt die AWS Region fest, in der Ihre Ressourcen gespeichert werden. + `configuration`: legt die Konfiguration fest, die für die Veröffentlichung Ihrer Funktion verwendet wurde. + `package-type`: legt den Typ des Bereitstellungspakets auf ein Container-Image oder ein ZIP-Dateiarchiv fest. + `function-memory-size`: legt die Speicherzuweisung für Ihre Funktion in MB fest. + `function-timeout`: Timeout ist die maximale Zeit in Sekunden, die eine Lambda-Funktion ausführen kann. Sie können dies in Schritten von 1 Sekunde bis zu einem Maximalwert von 15 Minuten anpassen. + `docker-host-build-output-dir`: legt das Ausgabeverzeichnis des Build-Prozesses fest, das den Anweisungen in der entspricht. `Dockerfile` + `image-command`: ist ein vollständig qualifizierter Name für Ihre Methode, der Code, für den die Lambda-Funktion ausgeführt werden soll. Die Syntax lautet:. `{Assembly}::{Namespace}.{ClassName}::{MethodName}` Weitere Informationen finden Sie unter [Handler-Signaturen](https://docs.aws.amazon.com/lambda/latest/dg/csharp-handler.html#csharp-handler-signatures). Wenn `image-command` Sie diese Einstellung festlegen, wird dieser Wert später im Veröffentlichungsassistenten von Visual Studio vorab aufgefüllt. Im Folgenden finden Sie ein Beispiel für eine aws-lambda-tools-defaults JSON-Datei, die mit dem.NET 8-Blueprint (Container Image) erstellt wurde. ``` { "Information": [ "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.", "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.", "dotnet lambda help", "All the command line options for the Lambda command can be specified in this file." ], "profile": "default", "region": "us-west-2", "configuration": "Release", "package-type": "image", "function-memory-size": 512, "function-timeout": 30, "image-command": "AWSLambdaDocker::AWSLambdaDocker.Function::FunctionHandler", "docker-host-build-output-dir": "./bin/Release/lambda-publish" } ``` ### 3. Function.cs Die `Function.cs` Datei definiert die C\$1-Funktionen, die als Lambda-Funktionen verfügbar gemacht werden sollen. Das `FunctionHandler` ist die Lambda-Funktionalität, die ausgeführt wird, wenn die Lambda-Funktion ausgeführt wird. `FunctionHandler`Ruft in diesem Projekt den `ToUpper()` Eingabetext auf. ## Auf Lambda veröffentlichen Docker-Images, die durch den Build-Prozess generiert werden, werden in Amazon Elastic Container Registry (Amazon ECR) hochgeladen. Amazon ECR ist eine vollständig verwaltete Docker-Container-Registry, die Sie zum Speichern, Verwalten und Bereitstellen von Docker-Container-Images verwenden. Amazon ECR hostet das Image, auf das Lambda dann verweist, um die programmierte Lambda-Funktionalität bereitzustellen, wenn es aufgerufen wird. **Um Ihre Funktion auf Lambda zu veröffentlichen** 1. Öffnen Sie im **Solution Explorer** das Kontextmenü für das Projekt (klicken Sie mit der rechten Maustaste darauf) und wählen Sie dann **Veröffentlichen, AWS Lambda um** das Fenster **Lambda-Funktion hochladen** zu öffnen. 1. Gehen **Sie auf der Seite Lambda-Funktion hochladen** wie folgt vor: ![\[Upload-Bildschirm für die Veröffentlichung der bildbasierten Lambda-Funktion auf AWS\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-docker-03192024.png) 1. Als **Pakettyp** **Image** wurde automatisch als **Pakettyp** ausgewählt, da der Veröffentlichungsassistent eine `Dockerfile` in Ihrem Projekt erkannt hat. 1. Geben Sie **unter Funktionsname** einen Anzeigenamen für Ihre Lambda-Instanz ein. Dieser Name ist der Referenzname, der sowohl im AWS Explorer in Visual Studio als auch im angezeigt wird AWS-Managementkonsole. 1. Geben Sie **unter Beschreibung** den Text ein, der zusammen mit Ihrer Instanz im angezeigt werden soll AWS-Managementkonsole. 1. Geben Sie für **Image Command** einen vollqualifizierten Pfad zu der Methode ein, die die Lambda-Funktion ausführen soll: **AWSLambdaDocker::AWSLambdaDocker.Function::FunctionHandler** **Anmerkung** Jeder hier eingegebene Methodenname überschreibt alle CMD-Anweisungen in der Dockerfile. Die Eingabe von **Image Command** ist nur optional, WENN Sie eine Anweisung `CMD` zum Starten der Lambda-Funktion `Dockerfile` enthalten. 1. Geben Sie für **Image Repo** den Namen einer neuen oder vorhandenen Amazon Elastic Container Registry ein. Das Docker-Image, das der Build-Prozess erstellt, wird in diese Registry hochgeladen. Die Lambda-Definition, die veröffentlicht wird, wird auf dieses Amazon ECR-Image verweisen. 1. Geben Sie für **Image-Tag** ein Docker-Tag ein, das mit Ihrem Image im Repository verknüpft werden soll. 1. Wählen Sie **Weiter** aus. 1. Wählen Sie auf der Seite mit den **erweiterten Funktionsdetails** unter **Rollenname** eine Rolle aus, die Ihrem Konto zugeordnet ist. Die Rolle wird verwendet, um temporäre Anmeldeinformationen für alle Amazon Web Services Services-Aufrufe bereitzustellen, die durch den Code in der Funktion ausgeführt werden. Wenn Sie noch keine Rolle haben, wählen Sie **Neue Rolle basierend auf AWS verwalteter Richtlinie** und wählen Sie dann **AWSLambdaBasicExecutionRole**. **Anmerkung** Ihr Konto muss über die Berechtigung zum Ausführen der ListPolicies IAM-Aktion verfügen. Andernfalls ist die Liste mit den **Rollennamen** leer. 1. Wählen Sie **Hochladen**, um den Upload- und Veröffentlichungsvorgang zu starten. **Anmerkung** Die Seite mit den **Upload-Funktionen** wird angezeigt, während die Funktion hochgeladen wird. Der Veröffentlichungsprozess erstellt dann das Image auf der Grundlage der Konfigurationsparameter, erstellt bei Bedarf das Amazon ECR-Repository, lädt das Image in das Repository hoch und erstellt das Lambda, das auf dieses Repository mit diesem Image verweist. Nachdem die Funktion hochgeladen wurde, wird die **Funktionsseite** geöffnet und die Konfiguration Ihrer neuen Lambda-Funktion wird angezeigt. 1. **Um die Lambda-Funktion manuell aufzurufen, geben Sie auf der Registerkarte **Testfunktion** den Text in das `hello image based lambda` Freitexteingabefeld für die Anforderung ein und wählen Sie dann Aufrufen.** **Ihr in Großbuchstaben konvertierter Text wird als Antwort angezeigt.** ![\[Die Registerkarte Testfunktion der veröffentlichten Funktionsansichtsseite enthält eine Schaltfläche zum manuellen Aufrufen der Lambda-Methode.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-invoke-docker-03192024.png) 1. Um das Repository anzuzeigen, wählen Sie im **AWS Explorer** unter **Amazon Elastic Container Service** die Option **Repositories** aus. Sie können die Ansicht **Function:** jederzeit erneut öffnen, indem Sie im **AWS Explorer** unter dem Knoten auf Ihre bereitgestellte Instance doppelklicken. **AWS Lambda** **Anmerkung** **Wenn Ihr AWS Explorer-Fenster nicht geöffnet ist, können Sie es über **Ansicht** -> Explorer andocken AWS ** 1. Beachten Sie zusätzliche bildspezifische Konfigurationsoptionen auf der Registerkarte **Konfiguration**. Diese Registerkarte bietet eine Möglichkeit, die, und `ENTRYPOINT``CMD`, `WORKDIR` die möglicherweise in der Dockerfile angegeben wurden, zu überschreiben. **Beschreibung** ist die Beschreibung, die Sie (falls vorhanden) beim Hochladen/Veröffentlichen eingegeben haben. ## Aufräumen Wenn Sie mit diesem Beispiel nicht weiterentwickeln möchten, denken Sie daran, die bereitgestellte Funktion und das ECR-Image zu löschen, damit Ihnen nicht genutzte Ressourcen in Ihrem Konto in Rechnung gestellt werden. + Funktionen können gelöscht werden, indem Sie mit der rechten Maustaste auf Ihre bereitgestellte Instanz klicken, die sich im **AWS Explorer unter dem Knoten** befindet. **AWS Lambda** + Repositorys können im **AWS Explorer** unter dem **Amazon Elastic Container Service** -> **Repositories** gelöscht werden. ## Nächste Schritte Informationen zum Erstellen und Testen von Lambda-Images finden Sie unter [Using Container Images with Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-images.html). [Informationen zur Bereitstellung von Container-Images, zu Berechtigungen und zum Überschreiben von Konfigurationseinstellungen finden Sie unter Funktionen konfigurieren.](https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html) # 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)` # Tutorial: Erstellen einer Amazon Rekognition-Lambda-Anwendung Dieses Tutorial zeigt Ihnen, wie Sie eine Lambda-Anwendung erstellen, die Amazon Rekognition verwendet, um Amazon S3 S3-Objekte mit erkannten Labels zu kennzeichnen. 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 ## Erstellen Sie ein Visual Studio-.NET Core Lambda Image Rekognition-Projekt Das folgende Verfahren beschreibt, wie Sie eine Amazon Rekognition Lambda-Anwendung aus dem erstellen. AWS Toolkit for Visual Studio **Anmerkung** Nach der Erstellung verfügt Ihre Anwendung über eine Lösung mit zwei Projekten: dem Quellprojekt, das Ihren Lambda-Funktionscode zur Bereitstellung auf Lambda enthält, und einem Testprojekt, das xUnit verwendet, um Ihre Funktion lokal zu testen. Manchmal kann Visual Studio nicht alle NuGet Referenzen für Ihre Projekte finden. Das liegt daran, dass Blueprints Abhängigkeiten erfordern, aus NuGet denen abgerufen werden muss. Wenn neue Projekte erstellt werden, ruft Visual Studio nur lokale Verweise ab und keine Remote-Verweise von. NuGet Um Fehler zu NuGet beheben, klicken Sie mit der rechten Maustaste auf Ihre Verweise und wählen Sie **Pakete wiederherstellen**. 1. Erweitern Sie in Visual Studio das Menü **Datei**, erweitern Sie **Neu** und wählen Sie dann **Projekt** aus. 1. Vergewissern Sie sich, dass im Dialogfeld „**Neues Projekt**“ 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 Vorlage **AWS Lambda mit Tests (.NET Core — C\$1)** aus. 1. Klicken Sie auf **Weiter**, um das Dialogfeld **Neues Projekt konfigurieren** zu öffnen. 1. Geben **Sie im Dialogfeld „Neues Projekt konfigurieren**“ ImageRekognition "als **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**“ den Blueprint „**Bildbeschriftungen erkennen**“ und anschließend „**Fertig stellen**“, um das Visual Studio-Projekt zu erstellen. **Anmerkung** Dieser Blueprint bietet Code zum Abhören von Amazon S3 S3-Ereignissen und verwendet Amazon Rekognition, um Labels zu erkennen und sie dem S3-Objekt als Tags hinzuzufügen. ## Projektdateien überprüfen In den folgenden Abschnitten werden diese Projektdateien untersucht: 1. `Function.cs` 1. `aws-lambda-tools-defaults.json` ### 1. Function.cs In der `Function.cs` Datei ist das erste Codesegment das Assemblyattribut, das sich oben in der Datei befindet. Standardmäßig akzeptiert Lambda nur Eingabeparameter und Rückgabetypen vom Typ`System.IO.Stream`. Sie müssen einen Serializer registrieren, um typisierte Klassen für Eingabeparameter und Rückgabetypen zu verwenden. Das Assembly-Attribut registriert den Lambda-JSON-Serializer, der Streams in `Newtonsoft.Json` typisierte Klassen konvertiert. Sie können den Serializer auf Assembly- oder Methodenebene festlegen. Im Folgenden finden Sie ein Beispiel für das Assembly-Attribut: ``` // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class. [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] ``` Die Klasse enthält zwei Konstruktoren. Der erste ist ein Standardkonstruktor, der verwendet wird, wenn Lambda Ihre Funktion aufruft. Dieser Konstruktor erstellt die Amazon S3- und Amazon Rekognition Service-Clients. Der Konstruktor ruft auch die AWS Anmeldeinformationen für diese Clients aus der IAM-Rolle ab, die Sie der Funktion bei der Bereitstellung zuweisen. Die AWS Region für die Clients ist auf die Region festgelegt, in der Ihre Lambda-Funktion ausgeführt wird. In diesem Blueprint möchten Sie dem Amazon S3 S3-Objekt nur dann Tags hinzufügen, wenn der Amazon Rekognition Rekognition-Service ein Mindestmaß an Vertrauen in das Label hat. Dieser Konstruktor prüft die Umgebungsvariable `MinConfidence`, um das Mindestmaß an Vertrauen zu ermitteln. Sie können diese Umgebungsvariable bei der Bereitstellung der Lambda-Funktion festlegen. Im Folgenden finden Sie ein Beispiel für den Konstruktor der ersten Klasse in: `Function.cs` ``` public Function() { this.S3Client = new AmazonS3Client(); this.RekognitionClient = new AmazonRekognitionClient(); var environmentMinConfidence = System.Environment.GetEnvironmentVariable(MIN_CONFIDENCE_ENVIRONMENT_VARIABLE_NAME); if(!string.IsNullOrWhiteSpace(environmentMinConfidence)) { float value; if(float.TryParse(environmentMinConfidence, out value)) { this.MinConfidence = value; Console.WriteLine($"Setting minimum confidence to {this.MinConfidence}"); } else { Console.WriteLine($"Failed to parse value {environmentMinConfidence} for minimum confidence. Reverting back to default of {this.MinConfidence}"); } } else { Console.WriteLine($"Using default minimum confidence of {this.MinConfidence}"); } } ``` Das folgende Beispiel zeigt, wie der zweite Konstruktor zum Testen verwendet werden kann. Das Testprojekt konfiguriert seine eigenen S3- und Rekognition-Clients und übergibt sie: ``` public Function(IAmazonS3 s3Client, IAmazonRekognition rekognitionClient, float minConfidence) { this.S3Client = s3Client; this.RekognitionClient = rekognitionClient; this.MinConfidence = minConfidence; } ``` Das Folgende ist ein Beispiel für die `FunctionHandler` Methode in der Datei. `Function.cs` ``` public async Task FunctionHandler(S3Event input, ILambdaContext context) { foreach(var record in input.Records) { if(!SupportedImageTypes.Contains(Path.GetExtension(record.S3.Object.Key))) { Console.WriteLine($"Object {record.S3.Bucket.Name}:{record.S3.Object.Key} is not a supported image type"); continue; } Console.WriteLine($"Looking for labels in image {record.S3.Bucket.Name}:{record.S3.Object.Key}"); var detectResponses = await this.RekognitionClient.DetectLabelsAsync(new DetectLabelsRequest { MinConfidence = MinConfidence, Image = new Image { S3Object = new Amazon.Rekognition.Model.S3Object { Bucket = record.S3.Bucket.Name, Name = record.S3.Object.Key } } }); var tags = new List(); foreach(var label in detectResponses.Labels) { if(tags.Count < 10) { Console.WriteLine($"\tFound Label {label.Name} with confidence {label.Confidence}"); tags.Add(new Tag { Key = label.Name, Value = label.Confidence.ToString() }); } else { Console.WriteLine($"\tSkipped label {label.Name} with confidence {label.Confidence} because maximum number of tags reached"); } } await this.S3Client.PutObjectTaggingAsync(new PutObjectTaggingRequest { BucketName = record.S3.Bucket.Name, Key = record.S3.Object.Key, Tagging = new Tagging { TagSet = tags } }); } return; } ``` `FunctionHandler` ist die Methode, die Lambda aufruft, nachdem die Instance erstellt wurde. Beachten Sie, dass der Eingabeparameter vom Typ `S3Event` und nicht `Stream` ist. Dies ist aufgrund des registrierten Lambda-JSON-Serializers möglich. Das `S3Event` enthält alle Informationen über das in Amazon S3 ausgelöste Ereignis. Die Funktion durchläuft alle S3-Objekte, die Teil des Ereignisses waren, und weist Rekognition an, die Bezeichner zu ermitteln. Nachdem die Bezeichner ermittelt wurden, werden sie dem S3-Objekt als Tags hinzugefügt. **Anmerkung** Der Code enthält Aufrufe von`Console.WriteLine()`. Wenn die Funktion in Lambda ausgeführt wird, werden alle Aufrufe zu Amazon CloudWatch Logs `Console.WriteLine()` umgeleitet. ### 2. aws-lambda-tools-defaults.json Die `aws-lambda-tools-defaults.json` Datei enthält Standardwerte, die der Blueprint so festgelegt hat, dass einige Felder im Bereitstellungsassistenten vorab ausgefüllt werden. Es ist auch hilfreich bei der Festlegung von Befehlszeilenoptionen für die Integration mit.NET Core CLI. Um auf die .NET Core CLI-Integration zuzugreifen, navigieren Sie zum Projektverzeichnis der Funktion und geben Sie Folgendes ein**dotnet lambda help**. **Anmerkung** Der Funktionshandler gibt an, welche Methode Lambda als Antwort auf die aufgerufene Funktion aufrufen soll. Das Format dieses Feldes ist:. `::::` Der Namespace muss im Typnamen enthalten sein. ## Bereitstellen der Funktion Das folgende Verfahren beschreibt, wie Sie Ihre Lambda-Funktion bereitstellen. 1. Klicken Sie im **Solution Explorer** mit der rechten Maustaste auf das Lambda-Projekt und wählen Sie In ** AWS Lambda veröffentlichen**, um das Fenster **Hochladen in zu AWS Lambda** öffnen. **Anmerkung** Die voreingestellten Werte werden aus der `aws-lambda-tools-defaults.json` Datei abgerufen. 1. Geben Sie AWS Lambda im Fenster „**Hochladen** in“ einen Namen in das Feld „**Funktionsname**“ ein und klicken Sie dann auf „**Weiter**“, um zum Fenster „**Erweiterte Funktionsdetails**“ zu gelangen. **Anmerkung** In diesem Beispiel wird der **Funktionsname** verwendet**ImageRekognition**. ![\[AWS Lambda function upload interface with package type, runtime, and configuration options.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-imgrek-03192024.png) 1. Wählen Sie im Fenster **Erweiterte Funktionsdetails** eine IAM-Rolle aus, die Ihrem Code die Erlaubnis erteilt, auf Ihre Amazon S3- und Amazon Rekognition Rekognition-Ressourcen zuzugreifen. **Anmerkung** Wenn Sie diesem Beispiel folgen, wählen Sie die Rolle aus. `AWSLambda_FullAccess` 1. Setzen Sie die Umgebungsvariable `MinConfidence` auf 60 und wählen Sie dann **Upload**, um den Bereitstellungsprozess zu starten. Der Veröffentlichungsvorgang ist abgeschlossen, wenn die **Funktionsansicht** im **AWS Explorer** angezeigt wird. ![\[AWS Lambda function configuration interface showing permissions, execution, and environment settings.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-imgrek-advanced-03192024.png) 1. Nach einer erfolgreichen Bereitstellung konfigurieren Sie Amazon S3 so, dass seine Ereignisse an Ihre neue Funktion gesendet werden, indem Sie zur Registerkarte **Ereignisquellen** navigieren. 1. Wählen Sie auf der Registerkarte **Ereignisquellen** die Schaltfläche **Hinzufügen** und dann den Amazon S3 S3-Bucket aus, um eine Verbindung mit Ihrer Lambda-Funktion herzustellen. **Anmerkung** Der Bucket muss sich in derselben AWS Region wie Ihre Lambda-Funktion befinden. ## Testen der -Funktion Nachdem die Funktion nun bereitgestellt und ein S3-Bucket als Ereignisquelle dafür konfiguriert wurde, öffnen Sie im **AWS Explorer** den S3-Bucket-Browser für den ausgewählten Bucket. Laden Sie anschließend einige Bilder hoch. Wenn der Upload abgeschlossen ist, können Sie überprüfen, ob Ihre Funktion ausgeführt wurde, indem Sie die Protokolle in der Ansicht Ihrer Funktion einsehen. Oder klicken Sie mit der rechten Maustaste auf die Bilder im Bucket-Browser und wählen Sie **Properties (Eigenschaften)** aus. Auf der Registerkarte **Tags** können Sie die Tags anzeigen, die auf Ihr Objekt angewendet wurden. ![\[Properties window showing metadata tags for an image file in a cloud storage bucket.\]](http://docs.aws.amazon.com/de_de/toolkit-for-visual-studio/latest/user-guide/images/lambda-object-properties.png) # Tutorial: Verwenden von Amazon Logging Frameworks mit AWS Lambda zum Erstellen von Anwendungsprotokollen Sie können Amazon CloudWatch Logs verwenden, um die Protokolle Ihrer Anwendung zu überwachen, zu speichern und darauf zuzugreifen. Um Protokolldaten in CloudWatch Logs zu übernehmen, verwenden Sie ein AWS SDK oder installieren Sie den CloudWatch Logs-Agenten, um bestimmte Protokollordner zu überwachen. CloudWatch Logs ist in mehrere gängige.NET-Logging-Frameworks integriert und vereinfacht so Arbeitsabläufe. Um mit der Arbeit mit CloudWatch Logs und .NET-Logging-Frameworks zu beginnen, fügen Sie Ihrer Anwendung das entsprechende NuGet Paket und die CloudWatch Logs-Ausgabequelle hinzu und verwenden Sie dann Ihre Logging-Bibliothek wie gewohnt. Auf diese Weise kann Ihre Anwendung Nachrichten mit Ihrem .NET-Framework protokollieren, sie an CloudWatch Logs senden und die Protokollmeldungen Ihrer Anwendung in der CloudWatch Logs-Konsole anzeigen. Sie können in der CloudWatch Logs-Konsole auch Metriken und Alarme einrichten, die auf den Protokollnachrichten Ihrer Anwendung basieren. Zu den unterstützten.NET-Protokollierungsframeworks gehören: + **NLog**: Die Ansicht finden Sie im Paket [nuget.org NLog ](https://www.nuget.org/packages/AWS.Logger.NLog). + **Log4net**[: Die Ansicht finden Sie im nuget.org Log4net-Paket.](https://www.nuget.org/packages/AWS.Logger.NLog) + **ASP.NET Core Logging Framework**[: Eine Ansicht finden Sie im Nuget.org ASP.NET Core Logging Framework-Paket.](https://www.nuget.org/packages/AWS.Logger.AspNetCore/) Im Folgenden finden Sie ein Beispiel für eine `NLog.config` Datei, die sowohl CloudWatch Logs als auch die Konsole als Ausgabe für Protokollnachrichten aktiviert, indem das `AWS.Logger.NLog` NuGet Paket und das Ziel hinzugefügt werden. AWS `NLog.config` ``` ``` Die Logging-Plugins bauen alle auf dem auf AWS SDK für .NET und authentifizieren Ihre AWS Anmeldeinformationen in einem Prozess, der dem SDK ähnelt. Im folgenden Beispiel werden die Berechtigungen beschrieben, die für das Logging-Plug-In für den Zugriff auf CloudWatch Logs erforderlich sind: **Anmerkung** Bei AWS den.NET-Logging-Plugins handelt es sich um ein Open-Source-Projekt. Weitere Informationen, Beispiele und Anweisungen finden Sie in den Abschnitten zu [Beispielen](https://github.com/aws/aws-logging-dotnet/tree/master/samples) und [Anweisungen](https://github.com/aws/aws-logging-dotnet/blob/master/README.md) im [AWS GitHubLogging.NET-Repository](https://github.com/aws/aws-logging-dotnet). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogGroups" ], "Resource": [ "arn:aws:logs:*:*:*" ] } ] } ``` ------