Centro sviluppatori/.NET su AWS/...

Carichi di lavoro .NET su AWS Lambda

MODULO 5

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 5: test di unità e debug

 MODULO DI APPRENDIMENTO

Tieni presente che puoi seguire gli esempi presentati qui, ma non è obbligatorio.

Esistono diversi modi per testare una funzione Lambda. La soluzione più semplice consiste nell'utilizzare e sviluppare i test di unità forniti nei modelli di progetti AWS Lambda. Per eseguire i test è sufficiente un test runner familiare in un IDE o il semplice test dotnet.

Un'altra opzione consiste nell'utilizzare lo strumento di test AWS .NET Mock Lambda. Al momento è in anteprima. Ciò consente sia di testare che di eseguire il debug delle funzioni Lambda. Lo strumento è incluso nel kit di strumenti AWS per Visual Studio. Tuttavia, è possibile scaricarlo per utilizzarlo con la linea di comando, VS Code e Rider.

Se sviluppi funzioni Lambda distribuite in container, l'emulatore di interfaccia di runtime ti consentirà di testare le funzioni in esecuzione all'interno del container.

Esistono strumenti di terze parti come localstack che puoi usare per testare le funzioni in locale, ma il modo migliore per eseguire test funzionali è distribuire le funzioni Lambda su AWS e testarle lì. AWS offre a tutti gli account 1 milione di richieste gratuite al mese e fino a 3,2 milioni di secondi di tempo di elaborazione al mese. Quindi ci sono pochissime ragioni per non testare le funzioni sul cloud AWS.

Consulta queste due pagine per ulteriori informazioni sui prezzi: Informazioni di base sul Piano gratuito AWS e Prezzi di AWS Lambda.

Con questi strumenti di test locali è facile eseguire anche alcune operazioni di debug. Un breve esempio verrà mostrato più avanti.

 Tempo richiesto per il completamento

30 minuti 

Progetto di test xUnit

Molti modelli di progetti di funzioni Lambda .NET includono un progetto di test xUnit. Senza alcuna modifica, è possibile eseguire il test in questo progetto e superarlo.
Crea una nuova funzione Lambda usando: 
dotnet new lambda.EmptyFunction -n FunctionWithTestProject
Passa alla directory FunctionWithTestProject/test/FunctionWithTestProject.Tests: 
cd FunctionWithTestProject/test/FunctionWithTestProject.Tests
Apri il progetto nel tuo IDE.

Apri il file FunctionWithTestProject.Tests.csproj e vedrai un riferimento al progetto della funzione Lambda. 
<ProjectReference Include="..\..\src\FunctionWithTestProject\FunctionWithTestProject.csproj" />

Dalla linea di comando, esegui i test utilizzando:

dotnet test
Vedrai un output simile a: 
Starting test execution, please wait...
A total of 1 test files matched the specified pattern.

Passed!  - Failed:     0, Passed:     1, Skipped:     0, Total:     1, Duration: < 1 ms - FunctionWithTestProject.Tests.dll (net6.0)
Ovviamente puoi aprire il progetto di test in Visual Studio, VS Code o Rider ed eseguire i test da lì.

In Visual Studio, vai al menu Test e seleziona Run All Tests (Esegui tutti i test). Si aprirà anche Test Explorer (Esplora test), dove vedrai i risultati dei test.
In Rider, vai al menu Test e seleziona Run All Tests (Esegui tutti i test) da Solution (Soluzione). In questo modo verranno eseguiti i test e si aprirà la finestra Unit Test (Test di unità), dove si vedranno i risultati.
Per VS Code, puoi eseguire facilmente singoli test o tutti i test in un file
Se i test invece sono in più file, avrai bisogno di un'estensione per il test runner. Per ulteriori informazioni sulla configurazione e sull'esecuzione dei test, consulta la documentazione dell'estensione.

Quando si modifica il codice nella funzione, si aggiorna il test come si farebbe con un normale progetto di test. Poiché questo è un progetto di test come qualsiasi altro che scrivi, puoi usare le stesse librerie per aiutarti, come moq.

Lo strumento di test AWS .NET Mock Lambda

Questo strumento consente di richiamare le funzioni Lambda in locale con un payload definito dall'utente ed esaminare la risposta.

Come accennato in precedenza, se utilizzi il kit di strumenti AWS in Visual Studio, lo strumento è già incluso.

Puoi utilizzare lo strumento con Visual Studio, VS Code, Rider o dalla linea di comando.

La linea di comando consente di eseguirlo in due modalità:

1. Con un'interfaccia utente basata su browser Web

2. Senza interfaccia utente

I passaggi successivi mostrano come utilizzare lo strumento dalla linea di comando; tuttavia, se preferisci puoi passare direttamente alla sezione su Visual Studio.

Installazione dello strumento

Per la linea di comando, VS Code e Rider, è necessario installare lo strumento.

Dalla linea di comando esegui: 
dotnet tool install -g Amazon.Lambda.TestTool-6.0
Se lo hai già installato, aggiornalo usando: 
dotnet tool update -g Amazon.Lambda.TestTool-6.0

Test dalla linea di comando

Utilizzando il progetto di esempio precedente, dalla linea di comando vai alla directory FunctionWithTestProject/src/FunctionWithTestProject.

Per eseguire il test dalla linea di comando, è necessario specificare l'opzione --no-ui e passare un payload. L'escape del payload varia a seconda della shell (interprete di comandi) utilizzata. La procedura riportata di seguito funziona per PowerShell.

Dalla linea di comando, esegui: 
dotnet lambda-test-tool-6.0 --no-ui --payload '\"hello\"'
Per bash utilizza: 
dotnet lambda-test-tool-6.0 --no-ui --payload '"hello"'
Dovresti vedere un output simile a: 
AWS .NET Core 6.0 Mock Lambda Test Tool (0.12.3)
Loaded local Lambda runtime from project output C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\bin/Debug/net6.0
Executing Lambda function without web interface
Found Lambda config file C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\aws-lambda-tools-defaults.json
... Using config file C:\dev\FunctionWithTestProject\src\FunctionWithTestProject\aws-lambda-tools-defaults.json
... Using function handler FunctionWithTestProject::FunctionWithTestProject.Function::FunctionHandler
... Using payload with the value "hello"
... Setting AWS_PROFILE environment variable to default.
... No default AWS region configured. The --region switch can be used to configure an AWS Region.
Captured Log information:    

Request executed successfully
Response:
"HELLO"
Press any key to exit
Nella sezione delle risposte puoi vedere l'output della funzione Lambda.

Test dell'interfaccia utente Web, avviato dalla linea di comando

È possibile utilizzare lo strumento anche dalla linea di comando per avviare un'interfaccia utente Web da testare.

Puoi inserire il tuo payload nell'interfaccia utente, ma in questo caso non dovrai preoccuparti dell'escape. In alternativa, è possibile scegliere tra una serie di payload di richieste di esempio. Questi consentono di simulare le richieste provenienti da altri servizi AWS, come S3, Kinesis, SQS, ecc.

Per ora, inserisci "hello" (comprese le virgolette) come payload e premi il pulsante Execute Function (Esegui funzione).

Nella sezione delle risposte, vedrai cosa ha restituito la funzione.

Se hai aggiunto istruzioni di log alla tua funzione, le vedrai nella sezione Log Output (Output del log).

Visual Studio

Se hai installato il kit di strumenti AWS per Visual Studio, allora hai già lo strumento di test AWS .NET Mock Lambda.

Apri il progetto FunctionWithTestProject/src/FunctionWithTestProject in Visual Studio.

Visual Studio creerà una cartella Properties (Proprietà) e al suo interno un file launchsettings.json che collega lo strumento di test AWS .NET Mock Lambda al codice.

Il file avrà un aspetto simile a questo: 
{
  "profiles": {
    "Mock Lambda Test Tool": {
      "commandName": "Executable",
      "commandLineArgs": "--port 5050",
      "workingDirectory": ".\\bin\\$(Configuration)\\net6.0",
      "executablePath": "%USERPROFILE%\\.dotnet\\tools\\dotnet-lambda-test-tool-6.0.exe"
    }
  }
}
Avvia l'applicazione premendo F5. Si aprirà la stessa pagina che hai visto sopra, inserisci il tuo payload e premi il pulsante Execute Function (Esegui funzione).

VS Code

Per utilizzare lo strumento di test AWS .NET Mock Lambda in VS Code, segui le istruzioni riportate qui: https://github.com/aws/aws-lambda-dotnet/tree/master/Tools/LambdaTestTool#configure-for-visual-studio-code

Nota:

1. dovresti cambiare dotnet-lambda-test-tool-3.1 in dotnet-lambda-test-tool-6.0.

2. se utilizzi Linux/Mac dotnet-lambda-test-tool-6.0 non avrà l'estensione .exe.

Rider

Per configurare lo strumento di test AWS .NET Mock Lambda per Rider, segui le istruzioni
riportate qui:

Container ed emulatore di interfaccia di runtime

Se distribuisci funzioni Lambda all'interno di container, puoi eseguire un altro livello di test locali utilizzando l'emulatore di interfaccia di runtime AWS (Runtime Interface Emulator, RIE). Non è necessario installare nuovi strumenti, essi verranno automaticamente impacchettati all'interno del container che crei.

Per questo esempio, scriverai un'applicazione serverless con due gestori di funzioni.

Crea un nuovo progetto basato su container utilizzando:

dotnet new serverless.image.EmptyServerless --name TestingFunctionWithRIE
Il progetto contiene un Dockerfile. Apri questo e vedrai che Docker copia i file dalla directory bin/Release/lambda-publish nel container Docker: 
COPY "bin/Release/lambda-publish"  .
Apri il file Function.cs e sostituisci il metodo Get(..) con quanto segue: 
public APIGatewayProxyResponse Get(APIGatewayProxyRequest request, ILambdaContext context)
{
    context.Logger.LogInformation($"Get method invoked. You requested {request.PathParameters["Id"]}");

    var response = new APIGatewayProxyResponse
    {
        StatusCode = (int)HttpStatusCode.OK,
        Body = $"You were looking for something with an Id of : {request.PathParameters["Id"]}",
      Headers = new Dictionary<string, string> {
        {
      "Content-Type",
      "application/json"
         }

        }
    };
            
    return response;
}
Passa alla directory TestingFunctionWithRIE/src/TestingFunctionWithRIE: 
cd TestingFunctionWithRIE/src/TestingFunctionWithRIE
Esegui quanto segue: 
dotnet build -c Release -o .\bin\Release\lambda-publish\
Ciò creerà l'applicazione e inserirà i file binari nella directory .\bin\Release\lambda-publish.

Assicurati che Docker sia in esecuzione e poi crea il container: 
docker build -t testing_function_with_rie:latest .
Al termine, è il momento di avviare il container: 
docker run -it -p 9000:8080 testing_function_with_rie:latest TestingFunctionWithRIE::TestingFunctionWithRIE.Functions::Get
Questo comando avvia il container Docker ed espone la porta interna 8080 tramite la porta 9000 del computer e passa il gestore della funzione come parametro. L'emulatore di interfaccia di runtime lo utilizza per eseguire il metodo appropriato nell'applicazione.

Se hai più di un gestore di funzioni nel tuo codice, dovresti testare ciascuno di essi a turno, avviando il container e passando ogni volta il gestore di funzioni appropriato.

Infine, invia una richiesta HTTP all'emulatore di interfaccia di runtime. Puoi usare Fiddler, Postman, Insomnia, ecc. Di seguito è riportata la richiesta da utilizzare con VS Code Rest Client o Rider Http Client: 
POST http://localhost:9000/2015-03-31/functions/function/invocations HTTP/1.1
content-type: application/json

{
    "PathParameters": {
        "Id": "999"
    }
}
Verrà visualizzata una risposta simile alla seguente: 
HTTP/1.1 200 OK
Date: Fri, 29 Jul 2022 18:03:56 GMT
Content-Length: 148
Content-Type: text/plain; charset=utf-8
Connection: close

{
  "statusCode": 200,
  "headers": {
    "Content-Type": "application/json"
  },
  "body": "You were looking for something with an Id of : 999",
  "isBase64Encoded": false
}
Se desideri modificare il codice e ripetere il test, usa la seguente procedura, che combina la build .NET, la build del container e avvia il container in una sola riga: 
dotnet build -c Release -o .\bin\Release\lambda-publish\ ; docker build -t testing_function_with_rie:latest . ; docker run -it -p 9000:8080 testing_function_with_rie:latest TestingFunctionWithRIE::TestingFunctionWithRIE.Functions::Get

Test della tua funzione Lambda su AWS

Gli strumenti di cui sopra sono ottimi per testare la funzione Lambda in locale e, anche se esistono strumenti che aiutano a simulare gli ambienti AWS, il modo migliore per testare la funzione è il servizio AWS Lambda.

AWS offre un piano generoso e sempre gratuito, che consente di eseguire gratuitamente un milione di richieste Lambda al mese e, se superi tale limite, il prossimo milione di esecuzioni costerà 0,20 USD o 0.0000002 USD per esecuzione. Ci sono alcune avvertenze sui prezzi relativi all'utilizzo della memoria e al tempo di esecuzione; consulta le pagine: Informazioni di base sul Piano gratuito AWS e Prezzi di AWS Lambda per ulteriori informazioni.

Sebbene gli strumenti di emulazione possano essere ottimi se non disponi di connettività Internet, potresti scoprire che non si comportano esattamente come i servizi AWS reali. Testare le funzioni Lambda in AWS significa non avere sorprese quando arriva il momento di distribuire il codice.

Tutto quello che devi fare è creare un progetto di test .NET; il modello xUnit è una buona scelta. Da lì, scrivi test funzionali per le funzioni Lambda che distribuisci su AWS.

dotnet new xunit -n LambdaTestProject

Per una panoramica dettagliata sui test delle funzioni Lambda .NET distribuite su AWS, consulta il post del blog Developing .NET Core AWS Lambda functions.

Debug

Di tanto in tanto potresti voler eseguire il debug della tua funzione Lambda in locale. Ci sono due semplici modi per farlo:

1. Inserendo un punto di interruzione nel progetto di test di unità e poi passando alla funzione.

2. Avviando lo strumento di test AWS .NET Mock Lambda dall'IDE, inserendo un punto di interruzione nella funzione ed eseguendo la funzione dallo strumento di test.

Utilizzo del progetto di test di unità

Lo stesso principio si applica quando si utilizzano Visual Studio, VS Code e Rider.

Apri il progetto di test e inserisci un punto di interruzione nel codice proprio nel punto in cui chiama la funzione Lambda.

Esegui il debug del test. Quando raggiungi il punto di interruzione, accedi alla funzione Lambda.
Ora sarai nel codice della funzione Lambda!


Utilizzo dello strumento di test AWS .NET Mock Lambda

Funziona anche con tutti e tre gli IDE, vedi sopra per le istruzioni se stai usando VS Code o Rider.

In Visual Studio, apri il progetto della funzione, non il progetto di test.

Inserisci un punto di interruzione nel gestore delle funzioni. Nell'interfaccia utente Web, aggiungi l'input della funzione e premi Execute (Esegui).

Il punto di interruzione verrà raggiunto e potrai eseguire il debug della funzione Lambda come con qualsiasi altro metodo.

Conclusioni

In questo modulo, hai visto diversi modi per testare ed eseguire il debug delle funzioni Lambda sia dalla linea di comando che dagli IDE.

Mano a mano che ti abitui a scrivere funzioni Lambda puoi passare da un modo all'altro per testare le funzioni, ma ti consigliamo vivamente di utilizzare il servizio AWS Lambda reale il prima possibile per testare il codice. È il posto migliore per farlo.

Hai visto inoltre come eseguire il debug di una funzione in locale, avendo modo di esaminare il codice e vedere cosa sta succedendo.


Verifica delle conoscenze

Ora hai completato il Modulo 5: test di unità e debug. Il seguente test ti consentirà di verificare ciò che hai appreso finora.

1. Quali IDE consentono di eseguire i test di unità delle funzioni Lambda? (seleziona una risposta)

a. Visual Studio

b. VS Code

c. Rider

d. Tutte le opzioni sopra indicate

2. Cosa consente di fare lo strumento di test AWS .NET Mock Lambda? (seleziona una risposta)

a. Dipendenze Mock .NET per i tuoi test

b. Simulazione dei servizi AWS per la chiamata della funzione Lambda

c. Eseguire test delle prestazioni sulle funzioni Lambda

d. Richiamare il codice della funzione in locale

3. Per quale tipo di funzione Lambda è adatto l'emulatore di interfaccia di runtime? (seleziona una risposta)

a. Funzioni Lambda in runtime gestite

b. Funzioni Lambda basate su container

c. Funzioni Lambda in runtime personalizzate

d. Tutti i tipi di funzioni Lambda

Risposte: 1-d, 2-d, 3-b

Conclusioni

In questo modulo, hai visto diversi modi per testare ed eseguire il debug delle funzioni Lambda sia dalla linea di comando che dagli IDE.

Mano a mano che ti abitui a scrivere funzioni Lambda puoi passare da un modo all'altro per testare le funzioni, ma ti consigliamo vivamente di utilizzare il servizio AWS Lambda reale il prima possibile per testare il codice. È il posto migliore per farlo.

Hai visto inoltre come eseguire il debug di una funzione in locale, avendo modo di esaminare il codice e vedere cosa sta succedendo.

Questa pagina è stata utile?

 Feedback
Inizia il Modulo 6

LABORATORIO PRATICO: CREAZIONE E DISTRIBUZIONE DI FUNZIONI LAMBDA