Modul 6: Praktische Übung: Lambda-Funktionen erstellen und bereitstellen
PRAKTISCHE ÜBUNG
Ziele der Übung
In diesen Übungen setzen Sie das, was Sie in diesem Kurs gelernt haben, in die Praxis um
Sie erstellen eine Vielzahl von .NET-6/7-Lambda-Funktionen, stellen sie bereit und rufen sie auf.
In diesem Modul gibt es 3 Übungen:
Übung 1: In Arm64 ausgeführte .NET 6 Web App
Übung 2: Eine Lambda-Funktion aus einem C#-Programm auf Ihrem Computer aufrufen
Übung 3: Eine Lambda-Funktion über eine andere aufrufen
Voraussetzungen
Sie haben ein AWS-Konto.
Sie haben einen AWS-Benutzer, an den die AdministratorAccess-Richtlinie angehängt ist. Weitere Informationen finden Sie im Abschnitt „Ein Hinweis zu Berechtigungen“ in Modul 3./p >
Sie haben das .NET 6 SDK installiert.
Sie haben die AWS-Erweiterungen für .NET CLI (dotnet lambda...) installiert.
Sie haben AWS Lambda für .NET-Core-Vorlagen installiert.
Sie haben PowerShell installiert. Wenn Sie es für Window/Mac/Linux installieren müssen, lesen Sie https://github.com/PowerShell/PowerShell.
Weitere Informationen zu den oben genannten Tools finden Sie in Modul 2.
Sie haben einen S3-Bucket für CloudFormation-Stacks. Andernfalls folgen Sie den nachstehenden Anweisungen.
Veranschlagte Zeit
45 Minuten
Übung 1: Eine in Arm64 ausgeführte .NET 6 Web App
Schritt 1: Das Projekt erstellen
1. .NET-Serverless-Projekt erstellen
dotnet new serverless.AspNetCoreWebApp -n AspNetCoreWebAppSchritt 2: Einige Änderungen am Code vornehmen
Sie können die using-Anweisung und den Namespace unverändert lassen, aber die IndexModel-Klasse durch Folgendes ersetzen:
public class IndexModel : PageModel
{
public string? Architecture { get; set; }
public string? DotnetVersion { get; set; }
public void OnGet()
{
Architecture = System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString();
DotnetVersion = Environment.Version.ToString();
}
}2. Index.cshtml aktualisieren
Ersetzen Sie den Inhalt der Datei bis auf </h2> durch:
@page
@model IndexModel
@{
ViewData["Title"] = "Home page";
}
<div class="text-center">
<h1 class="display-4">Welcome to .NET Lambda functions on AWS!</h1>
<h2>Your application is using .NET <code>@Model.DotnetVersion</code>, <code>@Model.Architecture</code>.</h2>
</div>Durch diese Änderungen können Sie sehen, welche Version von .NET und welchen Prozessortyp Sie verwenden
Schritt 3: Prozessorarchitektur konfigurieren
Öffnen Sie die Datei serverless.template.
Suchen Sie den Schlüssel „Handler“ und fügen Sie in der nächsten Zeile Folgendes hinzu:
"Architectures": ["arm64"],"AspNetCoreFunction": {
"Type": "AWS::Serverless::Function",
"Properties": {
"Handler": "AspNetCoreWebApp::AspNetCoreWebApp.LambdaEntryPoint::FunctionHandlerAsync",
"Architectures": ["arm64"],
Schritt 4: Die Funktion bereitstellen
dotnet lambda deploy-serverless --stack-name AspNetCoreWebApp --s3-bucket your-unique-bucket-name1234Sie sehen die Ausgabe für jeden Schritt der Bereitstellung, der bearbeitet und abgeschlossen wird.
8/9/2022 1:45 PM AspNetCoreFunctionProxyResourcePermissionProd CREATE_COMPLETE
8/9/2022 1:45 PM AspNetCoreWebApp CREATE_COMPLETE
Stack finished updating with status: CREATE_COMPLETE
Output Name Value
------------------------------ --------------------------------------------------
ApiURL https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/Prod/
Schritt 5: Bereinigen
dotnet lambda delete-serverless --stack-name AspNetCoreWebAppÜbung 2: Eine Lambda-Funktion aus einem C#-Programm auf Ihrem Computer aufrufen
Schritt 1: Lambda-Funktion erstellen
In diesem Schritt erstellen Sie ein leeres Lambda-Projekt.
1. Das Projekt erstellen
Wenn Sie sich immer noch in dem Verzeichnis befinden, das Sie für die vorherige Übung erstellt haben, wechseln Sie aus diesem Verzeichnis in ein sauberes Verzeichnis. Erstellen Sie eine neue Lambda-Funktion über die Befehlszeile:
dotnet new lambda.EmptyFunction -n GetS3BucketsSchritt 2: Codeänderungen
In diesem Schritt ändern Sie den generierten Projektcode.
1. Paket hinzufügen
Wechseln Sie zum Ordner GetS3Buckets\src\ GetS3Buckets und fügen Sie das AWS-SDK-S3-Paket zum Projekt hinzu:
cd GetS3Buckets\src\ GetS3Buckets
dotnet add package AWSSDK.S32. Function.cs aktualisieren
Öffnen Sie Function.cs in Ihrer IDE und ersetzen Sie den Code durch:
using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
// 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))]
namespace GetS3Buckets;
public class Function
{
public async Task<IEnumerable<string>> FunctionHandler(ILambdaContext context)
{
var s3Client = new AmazonS3Client();
ListBucketsRequest listBucketsRequest = new ListBucketsRequest();
ListBucketsResponse listBucketsResponse = await s3Client.ListBucketsAsync(listBucketsRequest);
var bucketNames = listBucketsResponse.Buckets.Select(b => b.BucketName);
return bucketNames;
}
}Schritt 3: Die Funktion bereitstellen
In diesem Schritt stellen Sie Ihre Lambda-Funktion bereit und testen sie.
1. Funktion in AWS bereitstellen
Stellen Sie die Funktion in AWS bereit, indem Sie:
dotnet lambda deploy-function GetS3Buckets
Wenn Sie aufgefordert werden, eine Rolle auszuwählen, wählen Sie die Option zum Erstellen einer neuen Rolle. Verwenden Sie als Rollennamen GetS3BucketsRole.
Wenn Sie aufgefordert werden, eine Richtlinie anzuhängen, wählen Sie die Option für AWSLambdaBasicExecutionRole, das ist Nummer 6 auf meiner Liste.
Schritt 4: Die Berechtigung zu ListAllMyBuckets hinzufügen
In diesem Schritt fügen Sie Berechtigungen hinzu, um Ihre S3-Buckets aufzulisten.
1. IAM-Richtlinie erstellen
Die Richtlinie, die Sie der Rolle zugeordnet haben, verfügt nicht über die erforderliche Berechtigung, um Ihre S3-Buckets aufzulisten.
Erstellen Sie eine neue Datei mit dem Namen S3ListAllMyBucketsPolicy.json.
Fügen Sie Folgendes in die Datei ein -
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": "*"
}
]
}2. Richtlinie zur Rolle hinzufügen
Fügen Sie die Richtlinie zu GetS3BucketsRole: hinzu.
aws iam put-role-policy --role-name GetS3BucketsRole --policy-name ListAllMyBuckets --policy-document file://S3ListAllMyBucketsPolicy.json
Warten Sie einen Moment, bis die Berechtigungen angewendet werden.
Schritt 5: Die Lambda-Funktion von der Befehlszeile aus aufrufen
In diesem Schritt stellen Sie Ihre Lambda-Funktion bereit und testen sie.
1. Die Funktion von der Befehlszeile aus aufrufen
Bevor Sie ein C#-Programm zum Aufrufen der Funktion erstellen, versuchen Sie, es von der Befehlszeile aus aufzurufen:
dotnet lambda invoke-function --function-name GetS3BucketsSie sollten eine Ausgabe sehen, die alle Ihre Buckets auflistet.
Dadurch wird sichergestellt, dass die Lambda-Funktion erwartungsgemäß funktioniert.
Schritt 6: Die Lambda-Funktion von der Befehlszeile aus aufrufen
In diesem Schritt erstellen Sie ein C#-Programm, das Ihre Lambda-Funktion aufruft.
1. Eine Konsolenanwendung erstellen
Erstellen Sie eine .NET-Konsolenanwendung mit:
dotnet new console -n GetS3BucketsCallFromLocal
2. AWSSDK.Lambda-Paket hinzufügen
Wechseln Sie in den Ordner GetS3BucketsCallFromLocal.
cd GetS3BucketsCallFromLocalFügen Sie das AWS-SDK-Lambda-Paket hinzu, damit Sie Lambda-Funktionen aufrufen können:
dotnet add package AWSSDK.Lambda3. Program.cs aktualisieren
Öffnen Sie die Datei Program.cs und ersetzen Sie sie durch:
using System.Text.Json;
using Amazon.Lambda;
using Amazon.Lambda.Model;
AmazonLambdaClient client = new AmazonLambdaClient();
var request = new InvokeRequest
{
FunctionName = "GetS3Buckets"
};
var result = await client.InvokeAsync(request);
var buckets = JsonSerializer.Deserialize<IEnumerable<string>>(result.Payload);
foreach (var bucket in buckets)
{
Console.WriteLine(bucket);
}Schritt 7: Testen
In diesem Schritt testen Sie das Konsolenprogramm und rufen Ihre Lambda-Funktion auf.
1. Die Konsolenanwendung ausführen
Führen Sie in der Befehlszeile des GetS3BucketsCallFromLocal-Verzeichnisses Folgendes aus:
dotnet run
Sie sollten eine Liste mit Bucket-Namen sehen.
Schritt 8: Bereinigen
Sie werden diese Funktion in der nächsten Übung verwenden, also müssen Sie vorerst nichts bereinigen.
Übung 3: Eine Lambda-Funktion über eine andere aufrufen
Schritt 1: Die Funktion GetS3Buckets erstellen
Schließen Sie die vorherige Übung ab.
Schritt 2: Lambda-Funktion erstellen
In diesem Schritt erstellen Sie eine Lambda-Funktion, um die GetS3Buckets-Funktionen aufzurufen.
1. Leeres Lambda-Projekt erstellen
Führen Sie in der Befehlszeile Folgendes aus:
dotnet new lambda.EmptyFunction -n GetS3BucketsCallFromLambdaFunction
2. Ordner ändern
Wechseln Sie in das Verzeichnis GetS3BucketsCallFromLambdaFunction\src\ GetS3BucketsCallFromLambdaFunction.
Schritt 3: Code aktualisieren
In diesem Schritt aktualisieren Sie den Projektcode.
1. AWSSDK.Lambda-Paket hinzufügen
Fügen Sie das AWS-SDK-Lambda-Paket zum Projekt hinzu:
dotnet add package AWSSDK.Lambda
2. Function.cs aktualisieren
Öffnen Sie die Datei Function.cs und ersetzen Sie den Code durch:
using Amazon.Lambda;
using Amazon.Lambda.Core;
using Amazon.Lambda.Model;
using System.Text.Json;
// 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))]
namespace GetS3BucketsCallFromLambdaFunction;
public class Function
{
public async Task<IEnumerable<string>> FunctionHandler(ILambdaContext context)
{
AmazonLambdaClient client = new AmazonLambdaClient();
var request = new InvokeRequest
{
FunctionName = "GetS3Buckets",
};
var result = await client.InvokeAsync(request);
var bucketNames = JsonSerializer.Deserialize<IEnumerable<string>>(result.Payload);
return bucketNames;
}
}In diesem Beispiel ruft die Lambda-Funktion GetS3BucketsCallFromLambdaFunction die GetS3Buckets-Funktion auf und gibt die Antwort zurück, ohne dass Änderungen an der Antwort vorgenommen werden.
Schritt 4: Die Funktion GetS3BucketsCallFromLambdaFunction bereitstellen
In diesem Schritt stellen Sie die Lambda-Funktion GetS3BucketsCallFromLambdaFunction in AWS bereit.
1. Die Funktion bereitstellen
Führen Sie in der Befehlszeile Folgendes aus:
dotnet lambda deploy-function GetS3BucketsCallFromLambdaFunction
2. Rolle erstellen
Erstellen Sie eine neue Rolle für die Funktion mit dem Namen
GetS3BucketsCallFromLambdaFunctionRole.3. Richtlinie an Rolle anhängen
Hängen Sie die Richtlinie AWSLambdaBasicExecutionRole an die Rolle an.
Schritt 5: Versuchen, GetS3BucketsCallFromLambdaFunction aufzurufen
In diesem Schritt versuchen Sie, die Funktion aufzurufen.
1. Die Funktion bereitstellen
Versuchen Sie, GetS3BucketsCallFromLambdaFunctionRole aufzurufen:
dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction
Sie erhalten eine Fehlermeldung wie die folgende:
Payload:
{
"errorType": "AmazonLambdaException",
"errorMessage": "User: arn:aws:sts::000000000000:assumed-role/GetS3BucketsCallFromLambdaFunctionRole/GetS3BucketsCallFromLambdaFunction
is not authorized to perform: lambda:InvokeFunction on resource: arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets because no
identity-based policy allows the lambda:InvokeFunction action",Dies liegt daran, dass GetS3BucketsCallFromLambdaFunction Berechtigungen zum Aufrufen von GetS3Buckets benötigt.
Im nächsten Schritt fügen Sie eine Inline-Richtlinie hinzu, die GetS3BucketsCallFromLambdaFunction die erforderliche Berechtigung gewährt
Schritt 6: GetS3BucketsCallFromLambdaFunction die Berechtigung erteilen, GetS3Buckets aufzurufen
In diesem Schritt erteilen Sie GetS3BucketsCallFromLambdaFunction die Berechtigung, GetS3Buckets aufzurufen.
1. ARN von GetS3Buckets erhalten
Bevor Sie GetS3BucketsCallFromLambdaFunction Aufrufrechte gewähren können, müssen Sie den Amazon-Ressourcennamen (ARN) von GetS3Buckets abrufen.
Sie können dies auf verschiedene Arten tun. Die erste Option ist von der AWS-Konsole aus. Lambda-Service aufrufen und die Funktion GetS3Buckets auswählen
Sie können in beiden hervorgehobenen Bereichen auf „Copy ARN“ (ARN kopieren) klicken.
Um den ARN von GetS3Buckets von der Befehlszeile abzurufen, führen Sie folgenden Befehl aus:
dotnet lambda get-function-config GetS3Buckets
Sie werden eine Ausgabe sehen, die wie folgt aussieht -
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli,
https://github.com/aws/aws-lambda-dotnet
Name: GetS3Buckets
Arn: arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets
Package Type: Zip
Runtime: dotnet6
Function Handler: GetS3Buckets::GetS3Buckets.Function::FunctionHandler
Last Modified: 2022-08-10T13:58:29.211+0000
Memory Size: 256
Ephemeral Storage Size: 512
Role: arn:aws:iam::000000000000:role/GetS3Buckets
Timeout: 30
Version: $LATEST
State: Active
Last Update Status: Successful
KMS Key ARN: (default) aws/lambdaDa sind viele nützliche Informationen, aber was Sie wollen, steht in der zweiten Zeile der Tabelle: der ARN.
Erstellen Sie eine Datei mit dem Namen InvokeGetS3Buckets.json und fügen Sie Folgendes hinzu:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets"
}
]
}
ReplErsetzen Sie die „Resource“ durch den ARN Ihrer Lambda-Funktion, den Sie über die Befehlszeile oder über die Konsolen-Benutzeroberfläche erhalten haben.
2. Berechtigungen aktualisieren
Führen Sie Folgendes aus:
aws iam put-role-policy --role-name GetS3BucketsCallFromLambdaFunctionRole
--policy-name InvokeGetS3BucketsFunction
--policy-document file://InvokeGetS3Buckets.jsonEs kann einige Minuten dauern, bis die Berechtigungen in AWS aktualisiert werden.
Schritt 7: GetS3BucketsCallFromLambdaFunction erneut aufrufen
In diesem Schritt rufen Sie die Funktion erneut auf.
1. Die Funktion mit dotnet lambda invoke-function aufrufen
Dieses Mal können Sie die Funktion aufrufen:
dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction
Zusammenfassung
In diesen Übungen haben Sie das Gelernte in die Praxis umgesetzt. Sie haben zuerst eine Webanwendung erstellt, auf die von überall auf der Welt zugegriffen werden kann. Anschließend haben Sie eine Lambda-Funktion bereitgestellt, die Sie direkt aus einem C#-Programm auf Ihrem Computer aufgerufen haben. Dann haben Sie in der zweiten Übung weitergemacht, indem Sie eine weitere Lambda-Funktion bereitgestellt und eine Lambda-Funktion von einer anderen aufgerufen haben. Sie mussten auch Probleme mit der Genehmigung lösen, sobald sie auftraten.
Von hier aus können Sie damit experimentieren, andere AWS-Services mit Lambda-Funktionen zu verwenden und komplexere Lambda-Anwendungen zu erstellen.