Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: crea e testa un'applicazione serverless con AWS Lambda
È possibile creare un'applicazione Lambda serverless utilizzando AWS Toolkit for Visual Studio un modello. I modelli di progetto Lambda ne includono uno per un'**applicazione AWS serverless**, che è l' AWS Toolkit for Visual Studio implementazione del [AWS Serverless Application Model](https://github.com/awslabs/serverless-application-model) (SAM).AWS Utilizzando questo tipo di progetto è possibile sviluppare una raccolta di AWS Lambda funzioni e distribuirle con tutte le AWS risorse necessarie come intera applicazione, utilizzandole per AWS CloudFormation orchestrare la distribuzione.
Per i prerequisiti e informazioni sulla configurazione di AWS Toolkit for Visual Studio, vedi [Uso dei modelli AWS Lambda nel Toolkit for AWS Visual Studio](lambda-index.md).
**Topics**
+ [Crea un nuovo progetto di applicazione serverless AWS](#create-a-new-aws-serverless-application-project)
+ [Revisione dei file dell'applicazione Serverless](#examine-the-files-in-the-serverless-application)
+ [Distribuzione dell'applicazione serverless](#deploy-the-serverless-application)
+ [Prova l'applicazione serverless](#test-the-serverless-application)
## Crea un nuovo progetto di applicazione serverless AWS
AWS I progetti di applicazioni serverless creano funzioni Lambda con un CloudFormation modello serverless. CloudFormation i modelli consentono di definire risorse aggiuntive come database, aggiungere ruoli IAM e distribuire più funzioni contemporaneamente. Ciò differisce dai progetti AWS Lambda, che si concentrano sullo sviluppo e l'implementazione di una singola funzione Lambda.
La procedura seguente descrive come creare un nuovo AWS progetto di applicazione Serverless.
1. Da Visual Studio espandi il menu **File**, espandi **Nuovo**, quindi scegli **Progetto**.
1. Nella finestra di dialogo **Nuovo progetto**, assicurati che le caselle a discesa **Lingua**, **Piattaforma** e **Tipo di progetto** siano impostate su «Tutto...» e inseriscile **aws lambda** nel campo **Cerca**.
1. Seleziona il modello **AWS Serverless Application with Tests (.NET Core - C\$1**).
**Nota**
È possibile che il modello **AWS Serverless Application with Tests (.NET Core - C\$1)** non compili nella parte superiore dei risultati.
1. Fate clic su **Avanti** per aprire la finestra di dialogo **Configura il nuovo progetto**.
1. Dalla finestra di dialogo **Configura il tuo nuovo progetto**, inserisci **ServerlessPowertools** il **nome**, quindi completa i campi rimanenti secondo le tue preferenze. Scegli il pulsante **Crea** per passare alla finestra di dialogo **Seleziona Blueprint**.
1. Dalla finestra di dialogo **Seleziona Blueprint** scegli **Powertools per** il AWS Lambda blueprint, quindi scegli **Fine** per creare il progetto Visual Studio.
## Revisione dei file dell'applicazione Serverless
Le seguenti sezioni forniscono una panoramica dettagliata di tre file di applicazioni serverless creati per il progetto:
1. serverless.template
1. Functions.cs
1. aws-lambda-tools-defaults.json
### 1. template senza server
Un `serverless.template` file è un AWS CloudFormation modello per dichiarare le funzioni Serverless e altre risorse. AWS Il file incluso in questo progetto contiene una dichiarazione per una singola funzione Lambda che verrà esposta tramite Amazon API Gateway come operazione`HTTP *Get*`. Puoi modificare questo modello per personalizzare la funzione esistente o aggiungere altre funzioni e altre risorse richieste dall'applicazione.
Di seguito è riportato un esempio di un file `serverless.template`:
```
{
"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/"
}
}
}
}
```
Nota che molti dei campi di `...AWS:: Serverless::Function...` dichiarazione sono simili ai campi della distribuzione di un progetto Lambda. Powertools Logging, Metrics and Tracing sono configurati tramite le seguenti variabili di ambiente:
+ POWERTOOLS\$1SERVICE\$1NAME= ServerlessGreeting
+ powertools\$1log\$1level=Informazioni
+ POWERTOOLS\$1LOGGER\$1CASE= PascalCase
+ PowerTools\$1Tracer\$1Capture\$1Response=Vero
+ powertools\$1tracer\$1capture\$1error=Vero
+ SPAZIO DEI NOMI POWERTOOLS\$1METRICS= ServerlessGreeting
[Per definizioni e dettagli aggiuntivi sulle variabili di ambiente, consultate il sito Web Powertools for References. AWS Lambda](https://awslabs.github.io/aws-lambda-powertools-dotnet/references/)
### 2. Functions.cs
`Functions.cs`è un file di classe contenente un metodo C\$1 mappato a una singola funzione dichiarata nel file modello. La funzione Lambda risponde ai `HTTP Get` metodi di API Gateway. Di seguito è riportato un esempio del `Functions.cs` file:
```
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`fornisce i valori predefiniti per la procedura guidata di AWS distribuzione all'interno di Visual Studio e i AWS Lambda comandi aggiunti al.NET Core CLI. Di seguito è riportato un esempio del `aws-lambda-tools-defaults.json` file incluso in questo progetto:
```
{
"profile": "Default",
"region": "us-east-1",
"configuration": "Release",
"s3-prefix": "ServerlessPowertools/",
"template": "serverless.template",
"template-parameters": ""
}
```
## Distribuzione dell'applicazione serverless
Per distribuire un'applicazione serverless, completa i seguenti passaggi
1. Da **Solution Explorer**, apri il menu contestuale del progetto (fai clic con il pulsante destro del mouse) e scegli **Pubblica su AWS Lambda per** aprire la finestra di dialogo **Pubblica applicazione AWS serverless**.
1. **Nella finestra di dialogo **Pubblica applicazione AWS serverless**, inserisci un nome per il contenitore dello CloudFormation stack nel campo Stack Name.**
1. **Nel campo **S3 Bucket, scegli un bucket** Amazon S3 su cui caricare il pacchetto di applicazioni o scegli il Nuovo...** pulsante e inserisci il nome di un nuovo bucket Amazon S3. Quindi scegli **Pubblica per pubblicare** per distribuire la tua applicazione.
**Nota**
CloudFormation Lo stack e Amazon S3 Bucket devono esistere nella stessa regione. AWS Le impostazioni rimanenti per il progetto sono definite nel file. `serverless.template`
![\[Immagine della finestra di dialogo Pubblica applicazione AWS serverless.\]](http://docs.aws.amazon.com/it_it/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-serverless-03192024.png)
1. La finestra di visualizzazione **dello stack** si apre durante il processo di pubblicazione. Una volta completata la distribuzione, viene visualizzato il campo **Status**:. `CREATE_COMPLETE`
![\[Immagine della finestra di visualizzazione dello stack di distribuzione in Visual Studio.\]](http://docs.aws.amazon.com/it_it/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-stackview-03192024.png)
## Prova l'applicazione serverless
Una volta completata la creazione dello stack, puoi visualizzare l'applicazione utilizzando l'URL **AWS Serverless**. Se hai completato questo tutorial senza aggiungere funzioni o parametri aggiuntivi, accedendo al tuo URL AWS serverless viene visualizzata la seguente frase nel tuo browser web:. `Hello Powertools for AWS Lambda (.NET)`