Centro sviluppatori/.NET su AWS/...

Carichi di lavoro .NET su AWS Lambda

MODULO 6

PANORAMICA DEL CORSO
INTRODUZIONE AD AWS LAMBDA
STRUMENTI PER LO SVILUPPO .NET
.NET SU AWS LAMBDA
LAVORARE CON ALTRI SERVIZI AWS
TEST DI UNITÀ E DEBUG
LABORATORIO PRATICO: CREAZIONE E DISTRIBUZIONE DI FUNZIONI LAMBDA
VALUTAZIONE DELLE COMPETENZE

Modulo 6 - Laboratorio pratico: creazione e distribuzione di funzioni Lambda

 LABORATORIO PRATICO

Obiettivi del laboratorio

Nei laboratori metterai in pratica ciò che hai imparato in questo corso

Potrai creare una serie di funzioni Lambda .NET 6/7, distribuirle e richiamarle.

Ci sono 3 laboratori in questo modulo:

Laboratorio 1: app Web .NET 6 in esecuzione su Arm64
Laboratorio 2: chiamata di una funzione Lambda da un programma C# sul computer
Laboratorio 3: chiamata di una funzione Lambda da un'altra funzione Lambda

Prerequisiti

Disponi di un account AWS.

Hai un utente AWS con la policy AdministratorAccess allegata; consulta la sezione Una nota sulle autorizzazioni, nel modulo 3 per maggiori dettagli./p>

Hai installato l'SDK .NET 6

Hai installato le estensioni AWS per la CLI .NET (dotnet lambda...).

Hai installato i modelli AWS Lambda per .NET Core.

Hai installato PowerShell. Se devi installarlo per Window/Mac/Linux, consulta https://github.com/PowerShell/PowerShell.

Puoi trovare maggiori informazioni sugli strumenti di cui sopra nel modulo 2.

Hai un bucket S3 per gli stack CloudFormation. In caso contrario, segui le istruzioni riportate di seguito.

 Tempo richiesto per il completamento

45 minuti

Lab 1: un'app Web .NET 6 in esecuzione su Arm64

Passaggio 1: creare il progetto

In questo passaggio creerai un progetto .NET serverless.

1. Crea un progetto .NET serverless

dotnet new serverless.AspNetCoreWebApp -n AspNetCoreWebApp
Ciò creerà il progetto all'interno della directory AspNetCoreWebApp\src\AspNetCoreWebApp.
2. Apri il progetto
Apri questo progetto nel tuo IDE preferito.

Passaggio 2: apportare alcune modifiche al codice

In questo passaggio modificherai il codice del progetto generato.
1. Aggiorna Index.cshtml.cs
Una volta aperto il progetto nell'IDE, apri Pages/Index.cshtml.cs nell'editor di codice.

È possibile lasciare l'istruzione using e lo spazio dei nomi così come sono, ma sostituire la classe IndexModel con quanto segue: 
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. Aggiorna Index.cshtml

Apri il file Pages/Index.cshtml.

Sostituisci il contenuto del file fino a </h2> con: 
@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>
Lascia l'elemento <svg> al suo posto.

Queste modifiche consentono di vedere la versione di .NET in esecuzione e il tipo di processore utilizzato

Passaggio 3: configurare l'architettura del processore

In questo passaggio imposterai l'architettura del processore su Arm64.
1. Cambia l'architettura del processore in Arm64
Un'altra modifica.

Apri il file serverless.template.

Trova la chiave "Handler" (Gestore) e aggiungi la riga successiva: 
"Architectures": ["arm64"],
Il blocco di codice ora dovrebbe essere simile al seguente: 
"AspNetCoreFunction": {
  "Type": "AWS::Serverless::Function",
  "Properties": {
    "Handler": "AspNetCoreWebApp::AspNetCoreWebApp.LambdaEntryPoint::FunctionHandlerAsync",
    "Architectures": ["arm64"],
2. Salva e crea
Salva tutte le modifiche e crea l'applicazione per verificare che non si verifichino errori di compilazione.

Passaggio 4: distribuire la funzione

In questo passaggio distribuirai e testerai la funzione Lambda.
1. Distribuisci la funzione su AWS
Dalla linea di comando esegui: 
dotnet lambda deploy-serverless --stack-name AspNetCoreWebApp --s3-bucket your-unique-bucket-name1234
Attendi che AWS distribuisca la funzione Lambda.

Vedrai l'output di ogni passaggio della distribuzione mano a mano che viene elaborato e completato. 
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/
2. Crea un progetto API Web .NET
Alla fine dell'output, ci sarà un ApiURL, aprilo nel tuo browser.

Passaggio 5: eseguire la pulizia

In questo passaggio eliminerai il progetto serverless da AWS.
1. Elimina il progetto serverless
Per rimuovere tutte le risorse create durante l'esecuzione: 
dotnet lambda delete-serverless --stack-name AspNetCoreWebApp

Laboratorio 2: chiamata di una funzione Lambda da un programma C# sul computer

Passaggio 1: creare la funzione Lambda

In questo passaggio, creerai un progetto Lambda vuoto.

1. Crea il progetto

Se ti trovi ancora nella directory che hai creato per il laboratorio precedente, spostati in una directory pulita. Crea una nuova funzione Lambda dalla linea di comando:

dotnet new lambda.EmptyFunction -n GetS3Buckets
Ciò creerà il progetto all'interno della directory AspNetCoreWebApp\src\AspNetCoreWebApp.

Passaggio 2: apportare modifiche al codice

In questo passaggio modificherai il codice del progetto generato.

1. Aggiungi pacchetto

Passa alla cartella GetS3Buckets\src\ GetS3Buckets e aggiungi il pacchetto AWS SDK S3 al progetto:

cd GetS3Buckets\src\ GetS3Buckets
dotnet add package AWSSDK.S3

2. Aggiorna Function.cs

Apri Function.cs nel tuo IDE e sostituisci il codice con:

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;
    }
}

Passaggio 3: distribuire la funzione

In questo passaggio distribuirai e testerai la funzione Lambda.

1. Distribuisci la funzione su AWS

Distribuisci la funzione su AWS utilizzando:

dotnet lambda deploy-function GetS3Buckets

Quando ti viene chiesto di selezionare un ruolo, scegli l'opzione per crearne uno nuovo. Usa il nome GetS3BucketsRole per il nome del ruolo.

Quando viene chiesto di allegare una policy, scegli l'opzione AWSLambdaBasicExecutionRole, che è la numero 6 sulla lista.

Passaggio 4: aggiungere l'autorizzazione a ListAllMyBuckets

In questo passaggio aggiungerai le autorizzazioni per elencare i tuoi bucket S3.

1. Crea una policy IAM

La policy che hai associato al ruolo non dispone dell'autorizzazione necessaria per elencare i tuoi bucket S3.

Crea un nuovo file chiamato S3ListAllMyBucketsPolicy.json.

Incolla quanto segue nel file:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:ListAllMyBuckets",
            "Resource": "*"
        }
    ]
}

2. Aggiungi policy al ruolo

Aggiungi la policy a GetS3BucketsRole:.

aws iam put-role-policy --role-name GetS3BucketsRole --policy-name ListAllMyBuckets --policy-document file://S3ListAllMyBucketsPolicy.json

Attendi qualche istante per l'applicazione delle autorizzazioni.

Passaggio 5: richiamare la funzione Lambda dalla linea di comando

In questo passaggio distribuirai e testerai la funzione Lambda.

1. Richiama la funzione dalla linea di comando

Prima di creare un programma C# per richiamare la funzione, prova a richiamarla dalla linea di comando:

dotnet lambda invoke-function --function-name GetS3Buckets

Dovresti vedere un output che elenca tutti i tuoi bucket.

In questo modo si verifica che la funzione Lambda funziona come previsto.

Passaggio 6: richiamare la funzione Lambda dalla linea di comando

In questo passaggio creerai un programma C# che richiama la funzione Lambda.

1. Crea un'applicazione per console

Crea un'applicazione .NET per console utilizzando:

dotnet new console -n GetS3BucketsCallFromLocal

2. Aggiungi il pacchetto AWSSDK.Lambda

Passa alla cartella GetS3BucketsCallFromLocal.

cd GetS3BucketsCallFromLocal

Aggiungi il pacchetto AWS SDK Lambda, che ti consente di richiamare le funzioni Lambda:

dotnet add package AWSSDK.Lambda

3. Aggiorna Program.cs

Apri il file Program.cs e sostituiscilo con:

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);
}

Passaggio 7: effettuare una prova

In questo passaggio testerai il programma della console e richiamerai la funzione Lambda.

1. Esegui l'applicazione per console

Dalla linea di comando della directory GetS3BucketsCallFromLocal, esegui:

dotnet run

Dovresti vedere un elenco di nomi dei bucket.

Passaggio 8: eseguire la pulizia

Utilizzerai questa funzione nel prossimo laboratorio, quindi non è necessario eseguire la pulizia per ora.

Laboratorio 3: chiamata di una funzione Lambda da un'altra funzione Lambda

Passaggio 1: creare la funzione GetS3Buckets

Completa il laboratorio precedente.

Passaggio 2: creare una funzione Lambda

In questo passaggio creerai una funzione Lambda per chiamare le funzioni GetS3Buckets.

1. Crea un progetto Lambda vuoto

Dalla linea di comando esegui:

dotnet new lambda.EmptyFunction -n GetS3BucketsCallFromLambdaFunction

2. Cambia cartella

Passa alla directory GetS3BucketsCallFromLambdaFunction\src\GetS3BucketsCallFromLambdaFunction.

Passaggio 3: aggiornare il codice

In questo passaggio aggiornerai il codice del progetto.

1. Aggiungi il pacchetto AWSSDK.Lambda

Aggiungi il pacchetto AWS SDK Lambda al progetto:

dotnet add package AWSSDK.Lambda

2. Aggiorna Function.cs

Apri il file Function.cs e sostituisci il codice con:

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 questo esempio, la funzione Lambda GetS3BucketsCallFromLambdaFunction chiama la funzione GetS3Buckets e restituisce la risposta senza modificarla.

Passaggio 4: distribuire la funzione GetS3BucketsCallFromLambdaFunction

In questo passaggio distribuirai la funzione Lambda GetS3BucketsCallFromLambdaFunction su AWS.

1. Distribuisci la funzione

Dalla linea di comando, esegui:

dotnet lambda deploy-function GetS3BucketsCallFromLambdaFunction

2. Crea ruolo

Crea un nuovo ruolo per la funzione denominato 

GetS3BucketsCallFromLambdaFunctionRole.

3. Allega la policy al ruolo

Allega la policy AWSLambdaBasicExecutionRole al ruolo.

Passaggio 5: provare a richiamare la funzione GetS3BucketsCallFromLambdaFunction

In questo passaggio proverai a richiamare la funzione.

1. Distribuisci la funzione

Prova a richiamare GetS3BucketsCallFromLambdaFunctionRole:

dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction

Riceverai un errore simile al seguente:

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",

Questo perché GetS3BucketsCallFromLambdaFunction richiede le autorizzazioni per richiamare GetS3Buckets.

Nel passaggio successivo aggiungerai una policy inline che concede a GetS3BucketsCallFromLambdaFunction l'autorizzazione necessaria

Passaggio 6: concedere a GetS3BucketsCallFromLambdaFunction l'autorizzazione per richiamare GetS3Buckets

In questo passaggio concederai a GetS3BucketsCallFromLambdaFunction le autorizzazioni per richiamare GetS3Buckets.

1. Ottieni l'ARN di GetS3Buckets

Prima di concedere i diritti di invocazione a GetS3BucketsCallFromLambdaFunction, è necessario ottenere il nome della risorsa Amazon (ARN) di GetS3Buckets.

Puoi farlo in un paio di modi. Innanzitutto dalla console AWS. Accedi al servizio Lambda e seleziona la funzione GetS3Buckets

Puoi fare clic su Copy ARN (Copia ARN) da entrambe le aree evidenziate.

Per ottenere l'ARN di GetS3Buckets dalla linea di comando, esegui:

dotnet lambda get-function-config GetS3Buckets

Vedrai un output simile a:

Pagina iniziale del progetto: 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/lambda

Ci sono molte informazioni utili, ma quello che cerchi è sulla seconda riga della tabella, l'Arn.

Crea un file chiamato InvokeGetS3Buckets.json, aggiungi quanto segue:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action":[
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:us-east-1:000000000000:function:GetS3Buckets"
        }
    ]
}
Repl

Sostituisci "Resource" (Risorsa) con l'ARN della funzione Lambda che hai ottenuto dalla linea di comando o dall'interfaccia utente della console.

2. Aggiorna le autorizzazioni

Esegui quanto segue:

aws iam put-role-policy --role-name GetS3BucketsCallFromLambdaFunctionRole
 --policy-name InvokeGetS3BucketsFunction 
 --policy-document file://InvokeGetS3Buckets.json

L'aggiornamento delle autorizzazioni su AWS potrebbe richiedere alcuni minuti.

Passaggio 7: richiamare nuovamente la funzione GetS3BucketsCallFromLambdaFunction

In questo passaggio richiamerai nuovamente la funzione.

1. Richiama la funzione con dotnet lambda invoke-function

Questa volta potrai richiamare la funzione:

dotnet lambda invoke-function --function-name GetS3BucketsCallFromLambdaFunction

Conclusioni

In questi laboratori metti in pratica ciò che hai imparato. Per prima cosa hai creato un'applicazione web accessibile da qualsiasi parte del mondo. Successivamente, hai distribuito una funzione Lambda che hai richiamato direttamente da un programma C# sul tuo computer. Poi hai continuato con il secondo laboratorio distribuendo un'altra funzione Lambda e richiamando una funzione Lambda da un'altra. Inoltre, hai dovuto risolvere i problemi di autorizzazione mano a mano che si sono verificati.

Da qui puoi sperimentare l'utilizzo di altri servizi AWS con funzioni Lambda e creare applicazioni Lambda più complesse.

Questa pagina è stata utile?

 Feedback
Inizia il Modulo 7

Valutazione delle competenze