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à.
# Distribuzione delle funzioni .NET Lambda con immagini di container
Esistono tre modi per creare un'immagine di container per una funzione Lambda in .NET:
+ [Utilizzo di un'immagine AWS di base per.NET](#csharp-image-instructions)
[Le immagini di base AWS](images-create.md#runtimes-images-lp) sono precaricate con un runtime in linguaggio, un client di interfaccia di runtime per gestire l'interazione tra Lambda e il codice della funzione e un emulatore di interfaccia di runtime per i test locali.
+ [Utilizzo di un'immagine di AWS base solo per il sistema operativo](images-create.md#runtimes-images-provided)
[AWS Le immagini di base solo](https://gallery.ecr.aws/lambda/provided) per il sistema operativo contengono una distribuzione Amazon Linux e l'emulatore [di interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md), e per un linguaggio o una versione di linguaggio per cui Lambda non fornisce un'immagine di base, come Node.js 19. Puoi anche utilizzare immagini di base solo per il sistema operativo al fine di implementare un [runtime personalizzato](runtimes-custom.md). Per rendere l'immagine compatibile con Lambda, devi includere il [client di interfaccia di runtime per .NET](#csharp-image-clients) nell'immagine.
+ [Utilizzo AWS di un'immagine non di base](#csharp-image-clients)
È possibile utilizzare un'immagine di base alternativa da un altro registro del container, come ad esempio Alpine Linux o Debian. Puoi anche utilizzare un'immagine personalizzata creata dalla tua organizzazione. Per rendere l'immagine compatibile con Lambda, devi includere il [client di interfaccia di runtime per .NET](#csharp-image-clients) nell'immagine.
**Suggerimento**
Per ridurre il tempo necessario all'attivazione delle funzioni del container Lambda, consulta [Utilizzo di compilazioni a più fasi](https://docs.docker.com/build/building/multi-stage/) nella documentazione Docker. Per creare immagini di container efficienti, segui le [best practice per scrivere file Docker](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Questa pagina spiega come creare, testare e implementare le immagini di container per Lambda.
**Topics**
+ [
## AWS immagini di base per.NET
](#csharp-image-base)
+ [
## Utilizzo di un'immagine AWS di base per.NET
](#csharp-image-instructions)
+ [
## Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime
](#csharp-image-clients)
## AWS immagini di base per.NET
AWS fornisce le seguenti immagini di base per.NET:
| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile per.NET 10 su GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | 14 novembre 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile per.NET 9 su GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | 10 novembre 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile per.NET 8 su GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | 10 novembre 2026 |
[Archivio Amazon ECR: gallery.ecr. aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Utilizzo di un'immagine AWS di base per.NET
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [SDK .NET](https://dotnet.microsoft.com/download): i passaggi seguenti utilizzano l'immagine di base .NET 8. Assicurati che la tua versione di .NET corrisponda alla versione dell'[immagine di base](https://gallery.ecr.aws/lambda/dotnet) specificata nel tuo Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
### Creazione e implementazione di un'immagine utilizzando un'immagine di base
Nei passaggi seguenti, utilizzerai [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) e [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) per creare un progetto .NET. Quindi, crei un'immagine Docker, carichi l'immagine su Amazon ECR e la implementi su una funzione Lambda.
1. Installa il pacchetto [Amazon.Lambda.Templates.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Crea un progetto .NET utilizzando il modello `lambda.image.EmptyFunction`.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
I file di progetto sono archiviati nella directory `MyFunction/src/MyFunction`:
+ **aws-lambda-tools-defaults.json**: specifica le opzioni della riga di comando per la distribuzione della funzione Lambda.
+ **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 la pagina [Serializzazione nelle funzioni Lambda C\$1](csharp-handler.md#csharp-handler-serializer). A fini di test, puoi utilizzare il codice fornito o sostituirlo con il tuo codice personalizzato.
+ **MyFunction.csproj**: un file di [progetto.NET, che elenca i file](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) e gli assembly che compongono l'applicazione.
+ **Dockerfile**: a fini di test, puoi utilizzare il Dockerfile fornito o sostituirlo con un file personalizzato. Se utilizzi un file personalizzato, assicurati di:
+ Imposta la proprietà `FROM` sull'[URI dell'immagine di base](https://gallery.ecr.aws/lambda/dotnet). L'immagine di base e la `TargetFramework` nel file `MyFunction.csproj` devono utilizzare entrambe la stessa versione di .NET. Ad esempio, per utilizzare .NET 9:
+ File Docker: `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj: `net9.0`
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda. Questo dovrebbe corrispondere a `image-command` in `aws-lambda-tools-defaults.json`.
1. Installa lo [strumento globale .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Se Amazon.Lambda.Tools è già installato, assicurati di disporre della versione più recente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Passa alla directory `MyFunction/src/MyFunction`, se non lo hai ancora fatto.
```
cd src/MyFunction
```
1. Utilizza Amazon.Lambda.Tools per creare l'immagine Docker, trasferirla in un nuovo repository Amazon ECR e implementare la funzione Lambda.
Per `--function-role`, specifica il nome del ruolo, non il nome della risorsa Amazon (ARN), del [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Ad esempio, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Per ulteriori informazioni sullo strumento globale Amazon.Lambda.Tools, consulta l'archivio Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI su. GitHub
1. Richiama la funzione.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
in caso di esito positivo, vedrai una risposta simile alla seguente:
```
Payload:
{"Lower":"testing the function","Upper":"TESTING THE FUNCTION"}
Log Tail:
INIT_REPORT Init Duration: 9999.81 ms Phase: init Status: timeout
START RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Version: $LATEST
END RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed
REPORT RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Duration: 3173.06 ms Billed Duration: 3174 ms Memory Size: 512 MB Max Memory Used: 24 MB
```
1. Elimina la funzione Lambda.
```
dotnet lambda delete-function MyFunction
```
## Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime
Se utilizzi un'[immagine di base solo per il sistema operativo](images-create.md#runtimes-images-provided) o un'immagine di base alternativa, devi includere il client dell'interfaccia di runtime nell'immagine. Il client dell'interfaccia di runtime estende l'[API Runtime](runtimes-api.md), che gestisce l'interazione tra Lambda e il codice della funzione.
L'esempio seguente mostra come creare un'immagine contenitore per.NET utilizzando un'immagine non di AWS base e come aggiungere [Amazon.Lambda. RuntimeSupport ](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)pacchetto, che è il client dell'interfaccia di runtime Lambda per .NET. Il Dockerfile di esempio utilizza l'immagine di base Microsoft .NET 8.
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [.NET SDK](https://dotnet.microsoft.com/download): i passaggi seguenti utilizzano un'immagine di base.NET 9. Assicurati che la tua versione di .NET corrisponda alla versione dell'immagine di base specificata nel tuo Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
### Creazione e implementazione di un'immagine utilizzando un'immagine di base alternativa
1. Installa il pacchetto [ NuGet Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates).
```
dotnet new install Amazon.Lambda.Templates
```
1. Crea un progetto .NET utilizzando il modello `lambda.CustomRuntimeFunction`. [Questo modello include Amazon.Lambda. RuntimeSupport](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)pacchetto.
```
dotnet new lambda.CustomRuntimeFunction --name MyFunction --region us-east-1
```
1. Passa alla directory `MyFunction/src/MyFunction`. Qui sono archiviati i file del progetto. Esamina i seguenti file di log:
+ **aws-lambda-tools-defaults.json**: in questo file si specificano le opzioni della riga di comando quando si distribuisce la funzione Lambda.
+ **Function.cs**: il codice contiene una classe con un metodo `Main` che inizializza la libreria `Amazon.Lambda.RuntimeSupport` come bootstrap. Il metodo `Main` sarà il punto di ingresso per il processo della funzione. Il metodo `Main` racchiude il gestore della funzione in un wrapper con cui il bootstrap può funzionare. [Per ulteriori informazioni, consulta Using Amazon.Lambda. RuntimeSupport come libreria di classi](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library) nel repository. GitHub
+ **MyFunction.csproj** — Un file di [progetto.NET, che elenca i file](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) e gli assembly che compongono l'applicazione.
+ **Readme.md**: questo file contiene ulteriori informazioni sulla funzione Lambda di esempio.
1. Apri il file `aws-lambda-tools-defaults.json` e aggiungi le righe seguenti.
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-type**: definisce il pacchetto di implementazione come immagine di container.
+ **docker-host-build-output-dir**: imposta la directory di output per il processo di compilazione.
**Example aws-lambda-tools-defaults.json**
```
{
"Information": [
"This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
"To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
"dotnet lambda help",
"All the command line options for the Lambda command can be specified in this file."
],
"profile": "",
"region": "us-east-1",
"configuration": "Release",
"function-runtime": "provided.al2023",
"function-memory-size": 256,
"function-timeout": 30,
"function-handler": "bootstrap",
"msbuild-parameters": "--self-contained true",
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
}
```
1. Crea un Dockerfile nella directory `MyFunction/src/MyFunction`. Il seguente Dockerfile di esempio utilizza un'immagine di base Microsoft .NET anziché un'[immagine di base AWS](#csharp-image-base).
+ Imposta la proprietà `FROM` sull'identificativo dell'immagine di base. L'immagine di base e la `TargetFramework` nel file `MyFunction.csproj` devono utilizzare entrambe la stessa versione di .NET.
+ Utilizza il comando `COPY` per copiare la funzione nella directory `/var/task`.
+ Imposta l'`ENTRYPOINT` sul modulo su cui desideri che il container Docker venga eseguito all'avvio. In questo caso, il modulo è il bootstrap, che inizializza la libreria `Amazon.Lambda.RuntimeSupport`.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
# You can also pull these images from DockerHub amazon/aws-lambda-dotnet:8
FROM mcr.microsoft.com/dotnet/runtime:9.0
# Set the image's internal work directory
WORKDIR /var/task
# Copy function code to Lambda-defined environment variable
COPY "bin/Release/net9.0/linux-x64" .
# Set the entrypoint to the bootstrap
ENTRYPOINT ["/usr/bin/dotnet", "exec", "/var/task/bootstrap.dll"]
```
1. Installa lo [strumento globale .NET Core](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Se Amazon.Lambda.Tools è già installato, assicurati di disporre della versione più recente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Utilizza Amazon.Lambda.Tools per creare l'immagine Docker, trasferirla in un nuovo repository Amazon ECR e implementare la funzione Lambda.
Per `--function-role`, specifica il nome del ruolo, non il nome della risorsa Amazon (ARN), del [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Ad esempio, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
[Per ulteriori informazioni sull'estensione CLI di Amazon.Lambda.Tools, consulta l'archivio Extensions for .NET CLI su.AWS](https://github.com/aws/aws-extensions-for-dotnet-cli) GitHub
1. Richiama la funzione.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
In caso di esito positivo, viene visualizzato quanto segue:
```
Payload:
"TESTING THE FUNCTION"
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
```
1. Elimina la funzione Lambda.
```
dotnet lambda delete-function MyFunction
```