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à.
# Crea e implementa le funzioni Lambda C\$1 con gli archivi di file .zip
Un pacchetto di implementazione .NET (archivio di file .zip) contiene l'assembly compilato della funzione insieme a tutte le dipendenze dell'assembly stesso. Il pacchetto contiene inoltre un file `proj.deps.json`, Ciò indica al runtime di .NET tutte le dipendenze della funzione e un file `proj.runtimeconfig.json` utilizzato per configurare il runtime.
Per implementare singole funzioni Lambda, puoi utilizzare l'interfaccia a riga di comando globale Lambda .NET `Amazon.Lambda.Tools`. L'utilizzo del comando `dotnet lambda deploy-function` crea automaticamente un pacchetto di implementazione .zip e lo distribuisce su Lambda. Tuttavia, ti consigliamo di utilizzare framework come AWS Serverless Application Model (AWS SAM) o AWS Cloud Development Kit (AWS CDK) per implementare le applicazioni .NET su AWS.
Le applicazioni serverless di solito comprendono una combinazione di funzioni Lambda e altri Servizi AWS gestiti che interagiscono per eseguire una particolare attività aziendale. AWS SAM e AWS CDK semplificano la creazione e l'implementazione di funzioni Lambda con altri Servizi AWS su larga scala. La [specifica del modello AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) fornisce una sintassi semplice e chiara per descrivere le funzioni Lambda, le API, le autorizzazioni, le configurazioni e altre risorse AWS che costituiscono l'applicazione serverless. Con il [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html) si definisce l'infrastruttura cloud come codice per creare applicazioni affidabili, scalabili e convenienti nel cloud utilizzando linguaggi di programmazione e framework di programmazione moderni come .NET. Sia AWS CDK che AWS SAM utilizzano la CLI globale Lambda di .NET per creare pacchetti di funzioni.
Anche se è possibile utilizzare [livelli Lambda](chapter-layers.md) con funzioni in C\$1 [tramite la CLI di .NET Core](csharp-package-cli.md#csharp-layers), tale scelta non è preferibile. Le funzioni in C\$1 che utilizzano livelli caricano manualmente gli assembly condivisi in memoria durante il [Fase di init](lambda-runtime-environment.md#runtimes-lifecycle-ib), per cui i tempi di avvio a freddo possono aumentare. Includi invece tutto il codice condiviso in fase di compilazione per evitare che il caricamento degli assembly al runtime comprometta le prestazioni.
Nelle sezioni seguenti sono riportate le istruzioni per la creazione e l'implementazione di funzioni Lambda .NET tramite AWS SAM, il AWS CDK e la CLI globale di Lambda di .NET.
**Topics**
+ [
# Utilizzo della CLI globale Lambda di .NET
](csharp-package-cli.md)
+ [
# Implementazione di funzioni Lambda C\$1 tramite AWS SAM
](csharp-package-sam.md)
+ [
# Implementazione di funzioni Lambda C\$1 tramite AWS CDK
](csharp-package-cdk.md)
+ [
# Implementa applicazioni ASP.NET
](csharp-package-asp.md)
# Utilizzo della CLI globale Lambda di .NET
La CLI .NET e l'estensione degli strumenti globali Lambda .NET (`Amazon.Lambda.Tools`) offrono un modo multi-piattaforma per creare applicazioni Lambda basate su .NET, impacchettarle e implementarle in Lambda. In questa sezione, scoprirai come creare nuovi progetti Lambda .NET utilizzando la CLI .NET e i modelli Amazon Lambda e come impacchettarli e implementarli tramite `Amazon.Lambda.Tools`
**Topics**
+ [
## Prerequisiti
](#csharp-package-cli-prerequisites)
+ [
## Creazione di progetti .NET con la CLI .NET
](#csharp-package-cli-create)
+ [
## Implementazione di progetti .NET con la CLI .NET
](#csharp-package-cli-deploy)
+ [
## Utilizzo dei livelli Lambda con la CLI di .NET
](#csharp-layers)
## Prerequisiti
**SDK .NET 8**
Se non l'hai già fatto, installa l'SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) e Runtime.
**Modelli di progetto .NET di AWS Amazon.Lambda.Templates**
Per generare il codice della funzione Lambda, usa il pacchetto [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet. Per installare questo pacchetto del modello, esegui il comando riportato:
```
dotnet new install Amazon.Lambda.Templates
```
**Strumenti della CLI globale .NET AWSAmazon.Lambda.Tools**
Per creare le funzioni Lambda, usa l'[estensione degli strumenti globali .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools). Per installare Amazon.Lambda.Tools, esegui il comando riportato:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Per ulteriori informazioni sull'estensione della CLI .NET Amazon.Lambda.Tools, consulta il repository [Estensioni AWS per la CLI .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) su GitHub.
## Creazione di progetti .NET con la CLI .NET
Nella CLI .NET, utilizzi il comando `dotnet new` per creare progetti .NET da una riga di comando. Lambda offre modelli aggiuntivi che utilizzano il pacchetto NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates).
Dopo aver installato questo pacchetto, esegui il comando di seguito per visualizzare un elenco di modelli disponibili.
```
dotnet new list
```
Per esaminare i dettagli relativi a un modello, utilizzare l'opzione `help`. Ad esempio, per visualizzare i dettagli del modello `lambda.EmptyFunction`, emetti il seguente comando.
```
dotnet new lambda.EmptyFunction --help
```
Per creare un modello di base per una funzione Lambda .NET, usa il modello `lambda.EmptyFunction`. In questo modo viene creata una funzione semplice che accetta una stringa come input e la converte in lettere maiuscole utilizzando il metodo `ToUpper`. Questo modello supporta le seguenti opzioni:
+ `--name`: il nome della funzione.
+ `--region`: la regione AWS in cui creare la funzione.
+ `--profile`: il nome di un profilo nel file delle credenziali AWS SDK per .NET. Per ulteriori informazioni sui profili di credenziali in .NET, consulta [Configurazione delle credenziali di AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) nella *Guida per gli sviluppatori di SDK AWS per .NET*.
In questo esempio, creiamo una nuova funzione vuota denominata `myDotnetFunction` utilizzando il profilo e le impostazioni di Regione AWS predefiniti:
```
dotnet new lambda.EmptyFunction --name myDotnetFunction
```
Questo comando crea i seguenti file e directory nella directory di progetto.
```
└── myDotnetFunction
├── src
│ └── myDotnetFunction
│ ├── Function.cs
│ ├── Readme.md
│ ├── aws-lambda-tools-defaults.json
│ └── myDotnetFunction.csproj
└── test
└── myDotnetFunction.Tests
├── FunctionTest.cs
└── myDotnetFunction.Tests.csproj
```
Nella directory `src/myDotnetFunction` esaminare i file seguenti:
+ **aws-lambda-tools-defaults.json**: file in cui si specificano le opzioni della riga di comando quando si distribuisce la funzione Lambda. Ad esempio:
```
"profile" : "default",
"region" : "us-east-2",
"configuration" : "Release",
"function-architecture": "x86_64",
"function-runtime":"dotnet8",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "myDotnetFunction::myDotnetFunction.Function::FunctionHandler"
```
+ **Function.cs**: codice della funzione del gestore Lambda. Si tratta di un modello C\$1 che include la libreria `Amazon.Lambda.Core` e un attributo `LambdaSerializer` predefiniti. Per ulteriori informazioni sui requisiti e sulle opzioni di serializzazione, consulta [Serializzazione nelle funzioni Lambda C\$1](csharp-handler.md#csharp-handler-serializer). Include anche una funzione di esempio che è possibile modificare per applicare il codice della funzione Lambda.
```
using Amazon.Lambda.Core;
// 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 myDotnetFunction;
public class Function
{
///
/// A simple function that takes a string and does a ToUpper
///
///
///
public string FunctionHandler(string input, ILambdaContext context)
{
return input.ToUpper();
}
}
```
+ **myDotnetFunction.csproj**: un file [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) in cui sono elencati i file e gli assembly che costituiscono l'applicazione.
```
net8.0
enable
enable
true
Lambda
true
true
```
+ **Readme**: file che consente di documentare la funzione Lambda.
Nella directory `myfunction/test` esaminare i file seguenti:
+ **myDotnetFunction.Tests.csproj**: come indicato in precedenza, si tratta di un file [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) in cui sono elencati file e assembly che costituiscono il progetto di test. Si noti anche che nel file è inclusa la libreria `Amazon.Lambda.Core`, che consente di integrare in modo semplice qualsiasi modello Lambda necessario per eseguire il test della funzione.
```
...
...
```
+ **FunctionTest.cs**: lo stesso file di modello del codice C\$1 incluso nella directory `src`. Modificare questo file per eseguire il mirroring del codice di produzione della funzione e per eseguirne il test prima di caricare la funzione Lambda in un ambiente di produzione.
```
using Xunit;
using Amazon.Lambda.Core;
using Amazon.Lambda.TestUtilities;
using MyFunction;
namespace MyFunction.Tests
{
public class FunctionTest
{
[Fact]
public void TestToUpperFunction()
{
// Invoke the lambda function and confirm the string was upper cased.
var function = new Function();
var context = new TestLambdaContext();
var upperCase = function.FunctionHandler("hello world", context);
Assert.Equal("HELLO WORLD", upperCase);
}
}
}
```
## Implementazione di progetti .NET con la CLI .NET
Per creare il pacchetto di implementazione e implementarlo in Lambda, utilizzi gli strumenti della CLI `Amazon.Lambda.Tools`. Per implementare la funzione dai file creati nei passaggi precedenti, per prima cosa accedi alla cartella contenente il file `.csproj` della funzione.
```
cd myDotnetFunction/src/myDotnetFunction
```
Per implementare il codice in Lambda come pacchetto di implementazione .zip, emetti il comando seguente. Scegli il nome della tua funzione.
```
dotnet lambda deploy-function myDotnetFunction
```
Durante l'implementazione, la procedura guidata chiede di selezionare un [Definizione delle autorizzazioni della funzione Lambda con un ruolo di esecuzione](lambda-intro-execution-role.md). Per questo esempio, seleziona `lambda_basic_role`.
Dopo aver implementato la funzione, puoi testarla nel cloud con il comando `dotnet lambda invoke-function`. Per il codice di esempio nel modello `lambda.EmptyFunction`, puoi testare la tua funzione inserendo una stringa utilizzando l'opzione `--payload`.
```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
```
Se la funzione è stata implementata con successo, dovresti vedere un output simile al seguente.
```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
Amazon Lambda Tools for .NET Core applications (5.8.0)
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli, https://github.com/aws/aws-lambda-dotnet
Payload:
"JUST CHECKING IF EVERYTHING IS OK"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 1 ms Memory Size: 256 MB Max Memory Used: 12 MB
```
## Utilizzo dei livelli Lambda con la CLI di .NET
**Nota**
Anche se è possibile utilizzare [livelli](chapter-layers.md) con funzioni in .NET, tale scelta non è preferibile. Le funzioni in .NET che utilizzano livelli caricano manualmente gli assembly condivisi in memoria durante la fase `Init`, per cui i tempi di avvio a freddo possono aumentare. Includi, invece, tutto il codice condiviso in fase di compilazione per sfruttare le ottimizzazioni integrate del compilatore .NET.
La CLI di .NET supporta comandi che facilitano la pubblicazione di livelli e l'implementazione di funzioni C\$1 che utilizzano livelli. Per pubblicare un livello in un bucket Amazon S3 specificato, utilizza il comando seguente nella stessa directory del tuo file `.csproj`:
```
dotnet lambda publish-layer --layer-type runtime-package-store --s3-bucket
```
Quando implementi la funzione utilizzando la CLI di .NET, quindi, specifica l'ARN utilizzato dal livello nel seguente comando:
```
dotnet lambda deploy-function --function-layers arn:aws:lambda:us-east-1:123456789012:layer:layer-name:1
```
Per un esempio completo di una funzione Hello World, consulta l'esempio [blank-csharp-with-layer](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-csharp-with-layer).
# Implementazione di funzioni Lambda C\$1 tramite AWS SAM
AWS Serverless Application Model (AWS SAM) è un toolkit che aiuta a semplificare il processo di creazione ed esecuzione di applicazioni serverless su AWS. Definisci le risorse per la tua applicazione in un modello YAML o JSON e usa l'interfaccia della linea di comando AWS SAM (AWS SAM CLI) per compilare, creare pacchetti e implementare le tue applicazioni. Quando crei una funzione Lambda da un modello AWS SAM, AWS SAM crea automaticamente un pacchetto di implementazione .zip o un'immagine di container con il codice della funzione e le dipendenze specificate.AWS SAM quindi implementa la funzione utilizzando uno [stack CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html). Per ulteriori informazioni sull'utilizzo di AWS SAM per creare e implementare funzioni Lambda, consulta la pagina [Nozioni di base su AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) nella *Guida introduttiva per gli sviluppatori di AWS Serverless Application Model*.
La seguente procedura mostra come scaricare, creare e implementare un'applicazione Hello World .NET di esempio con AWS SAM. Questa applicazione di esempio utilizza una funzione Lambda e un endpoint Gateway Amazon API per implementare un backend API di base. Quando invii una richiesta HTTP GET all'endpoint Gateway API, Gateway API richiama la funzione Lambda. La funzione restituisce un messaggio "hello world", insieme all'indirizzo IP dell'istanza della funzione Lambda che elabora la richiesta.
Quando crei e implementi l'applicazione utilizzando AWS SAM, dietro le quinte, la CLI AWS SAM utilizza il comando `dotnet lambda package` per impacchettare i singoli bundle di codici delle funzioni Lambda.
## Prerequisiti
**SDK .NET 8**
Installa l'SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) e Runtime.
**CLI AWS SAM versione 1.39 o successiva**
Per informazioni su come installare l'ultima versione della CLI AWS SAM, consulta [Installazione della CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
## Implementare un'applicazione AWS SAM di esempio
1. Inizializza l'applicazione utilizzando il modello .NET Hello world con il comando riportato di seguito.
```
sam init --app-template hello-world --name sam-app \
--package-type Zip --runtime dotnet8
```
Questo comando crea i seguenti file e directory nella directory di progetto.
```
└── sam-app
├── README.md
├── events
│ └── event.json
├── omnisharp.json
├── samconfig.toml
├── src
│ └── HelloWorld
│ ├── Function.cs
│ ├── HelloWorld.csproj
│ └── aws-lambda-tools-defaults.json
├── template.yaml
└── test
└── HelloWorld.Test
├── FunctionTest.cs
└── HelloWorld.Tests.csproj
```
1. Passa alla directory contenente il `template.yaml file`. Questo file è un modello che definisce le risorse AWS per l'applicazione, tra cui la funzione Lambda e un'API di Gateway API.
```
cd sam-app
```
1. Per creare il codice sorgente dell'applicazione, digita il comando riportato di seguito.
```
sam build
```
1. Per implementare l'applicazione su AWS, emetti il comando riportato di seguito:
```
sam deploy --guided
```
Questo comando impacchetta e implementa l'applicazione con la seguente serie di prompt. Per accettare le opzioni predefinite, premi Invio.
**Nota**
Per **HelloWorldFunction potrebbe non avere l'autorizzazione definita, va bene?**, assicurati di inserire `y`.
+ **Nome dello stack**: il nome dello stack da implementare su CloudFormation. Questo nome deve essere univoco per l'Account AWS e la Regione AWS.
+ **Regione AWS**: la Regione AWS in cui desideri implementare l'app.
+ **Conferma le modifiche prima dell'implementazione**: seleziona Sì per rivedere manualmente tutti i set di modifiche prima che AWS SAM implementi modifiche all'applicazione. Selezionando No, la CLI AWS SAM implementa automaticamente le modifiche alle applicazioni.
+ **Consenti la creazione di ruoli IAM per la CLI SAM**: numerosi modelli AWS SAM, incluso quello Hello world in questo esempio, creano ruoli AWS Identity and Access Management (IAM) per consentire alle funzioni Lambda di accedere ad altri Servizi AWS. Seleziona Sì per fornire l'autorizzazione a distribuire uno stack CloudFormation che crea o modifica i ruoli IAM.
+ **Disabilita il rollback**: per impostazione predefinita, se AWS SAM riporta un errore durante la creazione o l'implementazione dello stack, lo stack torna alla versione precedente. Seleziona No per accettare questa impostazione predefinita.
+ Per **HelloWorldFunction potrebbe non avere l'autorizzazione definita, va bene?**, immetti `y`.
+ **Salva gli argomenti in samconfig.toml**: seleziona Sì per salvare le tue scelte di configurazione. In futuro, potrai eseguire nuovamente `sam deploy` senza parametri per implementare le modifiche all'applicazione.
1. Una volta completata l'implementazione dell'applicazione, la CLI restituisce il nome della risorsa Amazon (ARN) della funzione Lambda Hello World e il ruolo IAM creato per essa. Consente inoltre di visualizzare anche l'endpoint dell'API di Gateway API. Per testare l'applicazione, apri l'endpoint in un browser. Si avrà una risposta simile alla seguente.
```
{"message":"hello world","location":"34.244.135.203"}
```
1. Per eliminare le risorse, emetti il seguente comando. Tieni presente che l'endpoint dell'API che hai creato è un endpoint pubblico accessibile su Internet. È consigliabile eliminare questo endpoint dopo il test.
```
sam delete
```
## Passaggi successivi
Per ulteriori informazioni su come utilizzare AWS SAM per creare e implementare le funzioni Lambda con .NET, consulta le seguenti risorse:
+ La [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
+ [Creazione di applicazioni .NET serverless con AWS Lambda e la CLI SAM](https://aws.amazon.com/blogs/dotnet/building-serverless-net-applications-with-aws-lambda-and-the-sam-cli/)
# Implementazione di funzioni Lambda C\$1 tramite AWS CDK
AWS Cloud Development Kit (AWS CDK) è un framework di sviluppo software open source per definire l'infrastruttura cloud come codice con linguaggi di programmazione e framework di programmazione moderni come .NET. I progetti AWS CDK vengono eseguiti per generare modelli CloudFormation che vengono poi utilizzati per implementare il codice.
Per creare e implementare un'applicazione .NET Hello world di esempio utilizzando ilAWS CDK, segui le istruzioni nelle sezioni seguenti. L'applicazione di esempio implementa un backend di API di base che consiste di un endpoint Gateway API e di una funzione Lambda. Quando si invia una richiesta HTTP GET all'endpoint, Gateway API richiama la funzione Lambda. La funzione restituisce un messaggio "hello world", insieme all'indirizzo IP dell'istanza Lambda che elabora la richiesta.
## Prerequisiti
**SDK .NET 8**
Installa l'SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) e Runtime.
**AWS CDK versione 2**
Per informazioni su come installare la versione più recente di AWS CDK, consulta la [Nozioni di base sul AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) nella *Guida per gli sviluppatori di AWS Cloud Development Kit (AWS CDK) v2*.
## Implementare un'applicazione AWS CDK di esempio
1. Crea una directory di progetto per l'applicazione di esempio e passa ad essa.
```
mkdir hello-world
cd hello-world
```
1. Inizializza una nuova applicazione AWS CDK eseguendo il comando riportato di seguito.
```
cdk init app --language csharp
```
Questo comando crea i seguenti file e directory nella directory di progetto.
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
└── HelloWorld.sln
```
1. Apri la directory `src` e crea una nuova funzione Lambda utilizzando la CLI .NET. Questa è la funzione che implementerai utilizzando il AWS CDK. In questo esempio, viene creata una funzione Hello world denominata `HelloWorldLambda` utilizzando il modello `lambda.EmptyFunction`.
```
cd src
dotnet new lambda.EmptyFunction -n HelloWorldLambda
```
Dopo questo passaggio, la struttura di directory all'interno della directory del progetto dovrebbe avere un aspetto simile al seguente.
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
├── HelloWorld.sln
└── HelloWorldLambda
├── src
│ └── HelloWorldLambda
│ ├── Function.cs
│ ├── HelloWorldLambda.csproj
│ ├── Readme.md
│ └── aws-lambda-tools-defaults.json
└── test
└── HelloWorldLambda.Tests
├── FunctionTest.cs
└── HelloWorldLambda.Tests.csproj
```
1. Apri il file `HelloWorldStack.cs` nella directory `src/HelloWorld`. Sostituisci il contenuto del file con il seguente codice.
```
using Amazon.CDK;
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.Logs;
using Constructs;
namespace CdkTest
{
public class HelloWorldStack : Stack
{
internal HelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var buildOption = new BundlingOptions()
{
Image = Runtime.DOTNET_8.BundlingImage,
User = "root",
OutputType = BundlingOutput.ARCHIVED,
Command = new string[]{
"/bin/sh",
"-c",
" dotnet tool install -g Amazon.Lambda.Tools"+
" && dotnet build"+
" && dotnet lambda package --output-package /asset-output/function.zip"
}
};
var helloWorldLambdaFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.DOTNET_8,
MemorySize = 1024,
LogRetention = RetentionDays.ONE_DAY,
Handler = "HelloWorldLambda::HelloWorldLambda.Function::FunctionHandler",
Code = Code.FromAsset("./src/HelloWorldLambda/src/HelloWorldLambda", new Amazon.CDK.AWS.S3.Assets.AssetOptions
{
Bundling = buildOption
}),
});
}
}
}
```
Questo è il codice per compilare e raggruppare il codice dell'applicazione, nonché la definizione della funzione Lambda stessa. L'oggetto `BundlingOptions` consente di creare un file zip, insieme a una serie di comandi utilizzati per generare il contenuto del file zip. In questa istanza, il comando `dotnet lambda package` viene utilizzato per compilare e generare il file zip.
1. Per implementare l'applicazione, emetti il comando riportato di seguito.
```
cdk deploy
```
1. Invoca la funzione Lambda implementata utilizzando la CLI .NET Lambda.
```
dotnet lambda invoke-function HelloWorldFunction -p "hello world"
```
1. Una volta terminato il test, potrai eliminare le risorse create (a meno che non si desideri mantenerle). Per eliminare le risorse, emetti il seguente comando.
```
cdk destroy
```
## Passaggi successivi
Per ulteriori informazioni su come utilizzare AWS CDK per creare e implementare le funzioni Lambda con .NET, consulta le seguenti risorse:
+ [Operazioni con il CDK AWS in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Crea, impacchetta e pubblica funzioni Lambda C\$1 .NET CDK AWS](https://aws.amazon.com/blogs/modernizing-with-aws/build-package-publish-dotnet-csharp-lambda-functions-aws-cdk/)
# Implementa applicazioni ASP.NET
Oltre a ospitare funzioni basate sugli eventi, puoi utilizzare .NET con Lambda anche per ospitare applicazioni ASP.NET leggere. Puoi creare e implementare applicazioni ASP.NET utilizzando il pacchetto `Amazon.Lambda.AspNetCoreServer` NuGet. In questa sezione, imparerai come distribuire un'API Web ASP.NET in Lambda utilizzando gli strumenti della CLI .NET Lambda.
**Topics**
+ [
## Prerequisiti
](#csharp-package-asp-prerequisites)
+ [
## Implementazione di un'API Web ASP.NET in Lambda
](#csharp-package-asp-deploy-api)
+ [
## Implementazione di API minime ASP.NET su Lambda
](#csharp-package-asp-deploy-minimal)
## Prerequisiti
**SDK .NET 8**
Installa l'SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) e ASP.NET Core Runtime.
**Amazon.Lambda.Tools**
Per creare le funzioni Lambda, usa l'[estensione degli strumenti globali .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools). Per installare Amazon.Lambda.Tools, esegui il comando riportato:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Per ulteriori informazioni sull'estensione della CLI .NET Amazon.Lambda.Tools, consulta il repository [Estensioni AWS per la CLI .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) su GitHub.
**Amazon.Lambda.Templates**
Per generare il codice della funzione Lambda, usa il pacchetto [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet. Per installare questo pacchetto del modello, esegui il comando riportato:
```
dotnet new --install Amazon.Lambda.Templates
```
## Implementazione di un'API Web ASP.NET in Lambda
Per implementare un'API Web utilizzando ASP.NET, puoi utilizzare i modelli Lambda .NET per creare un nuovo progetto di API Web. Utilizza il comando seguente per inizializzare un nuovo progetto di API Web ASP.NET. Nel comando di esempio, diamo un nome al progetto `AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Questo comando crea i seguenti file e directory nella directory di progetto.
```
.
└── AspNetOnLambda
├── src
│ └── AspNetOnLambda
│ ├── AspNetOnLambda.csproj
│ ├── Controllers
│ │ └── ValuesController.cs
│ ├── LambdaEntryPoint.cs
│ ├── LocalEntryPoint.cs
│ ├── Readme.md
│ ├── Startup.cs
│ ├── appsettings.Development.json
│ ├── appsettings.json
│ ├── aws-lambda-tools-defaults.json
│ └── serverless.template
└── test
└── AspNetOnLambda.Tests
├── AspNetOnLambda.Tests.csproj
├── SampleRequests
│ └── ValuesController-Get.json
├── ValuesControllerTests.cs
└── appsettings.json
```
Quando Lambda richiama la funzione, il punto di ingresso che utilizza è il file `LambdaEntryPoint.cs`. Il file creato dal modello Lambda .NET contiene il seguente codice.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
Il punto di ingresso utilizzato da Lambda deve ereditare da una delle tre classi base del pacchetto `Amazon.Lambda.AspNetCoreServer`. Queste tre classi base sono:
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
La classe predefinita utilizzata quando si crea il file `LambdaEntryPoint.cs` utilizzando il modello Lambda .NET fornito è `APIGatewayProxyFunction`. La classe base che usi nella tua funzione dipende dal livello API che precede la tua funzione Lambda.
Ciascuna delle tre classi base contiene un metodo pubblico denominato `FunctionHandlerAsync`. Il nome di questo metodo farà parte della [stringa del gestore](csharp-handler.md#csharp-class-library-handlers) che Lambda usa per richiamare la tua funzione. Il metodo `FunctionHandlerAsync` trasforma il payload dell'evento in entrata nel formato ASP.NET corretto e la risposta ASP.NET in un payload di risposta Lambda. Per il progetto `AspNetOnLambda` di esempio mostrato, la stringa del gestore sarebbe la seguente.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Per implementare l'API in Lambda, emetti i seguenti comandi per navigare nella directory contenente il file del codice sorgente e implementa la funzione utilizzando CloudFormation.
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**Suggerimento**
Quando implementi un'API utilizzando il comando `dotnet lambda deploy-serverless`, CloudFormation assegna alla funzione Lambda un nome basato sul nome dello stack specificato durante l'implementazione. Per assegnare un nome personalizzato alla funzione Lambda, modifica il file `serverless.template` in modo da aggiungere una proprietà `FunctionName` alla risorsa `AWS::Serverless::Function`. Consulta [Tipo di nome](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) nella *Guida per l'utente di CloudFormation* per ulteriori informazioni.
## Implementazione di API minime ASP.NET su Lambda
Per implementare un'API minima ASP.NET, puoi utilizzare i modelli Lambda .NET per creare un nuovo progetto di API minima. Utilizza il comando seguente per inizializzare un nuovo progetto di API minima ASP.NET. In questo esempio, al progetto assegnamo il nome `MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
Questo comando crea i seguenti file e directory nella directory di progetto.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
Il file `Program.cs` contiene il seguente codice.
```
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Add AWS Lambda support. When application is run in Lambda Kestrel is swapped out as the web server with Amazon.Lambda.AspNetCoreServer. This
// package will act as the webserver translating request and responses between the Lambda event source and ASP.NET Core.
builder.Services.AddAWSLambdaHosting(LambdaEventSource.RestApi);
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.MapGet("/", () => "Welcome to running ASP.NET Core Minimal API on AWS Lambda");
app.Run();
```
Per configurare l'API minima da eseguire su Lambda, potrebbe essere necessario modificare questo codice in modo che le richieste e le risposte tra Lambda e ASP.NET Core vengano tradotte correttamente. Per impostazione predefinita, la funzione è configurata per un'origine di eventi della REST API. Per un'API HTTP o un Application Load Balancer, sostituisci `(LambdaEventSource.RestApi)` con una delle seguenti opzioni:
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Per implementare l'API minima in Lambda, emetti i seguenti comandi per navigare nella directory contenente il file del codice sorgente e implementa la funzione utilizzando CloudFormation.
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```