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à.
# Personalizza le build con AWS SAM
Puoi personalizzare la build per includere funzioni Lambda o layer Lambda specifici. Una funzione è una risorsa che è possibile invocare per eseguire il codice in Lambda. Un layer Lambda consente di estrarre codice da una funzione Lambda che può quindi essere riutilizzato in diverse funzioni Lambda. Puoi scegliere di personalizzare la tua build con funzioni Lambda specifiche se desideri concentrarti sullo sviluppo e la distribuzione di singole funzioni serverless senza la complessità della gestione di dipendenze o risorse condivise. Inoltre, puoi scegliere di creare un layer Lambda per aiutarti a ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e consentire di condividere le dipendenze tra più funzioni.
Gli argomenti di questa sezione esplorano alcuni dei diversi modi con cui è possibile creare funzioni Lambda. AWS SAM Ciò include la creazione di funzioni Lambda con i runtime dei clienti e la creazione di layer Lambda. I runtime personalizzati consentono di installare e utilizzare un linguaggio non elencato nei runtime Lambda nella Developer Guide. AWS Lambda Ciò consente di creare un ambiente di esecuzione specializzato per l'esecuzione di funzioni e applicazioni serverless. La creazione di soli livelli Lambda (anziché la creazione dell'intera applicazione) può apportare vantaggi in alcuni modi. Può aiutarvi a ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e consentire di condividere le dipendenze tra più funzioni.
Per ulteriori informazioni sulle funzioni, consulta i [concetti di Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) nella *AWS Lambda Developer* Guide.
**Topics**
+ [Creazione di funzioni Lambda Node.js con esbuild in AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Creazione di funzioni.NET Lambda con la compilazione AOT nativa in AWS SAM](build-dotnet7.md)
+ [Creazione di funzioni Rust Lambda con in Cargo Lambda AWS SAM](building-rust.md)
+ [Creazione di funzioni Lambda in Python con in uv AWS SAM](building-python-uv.md)
+ [Creazione di funzioni Lambda con runtime personalizzati in AWS SAM](building-custom-runtimes.md)
+ [Creazione di livelli Lambda in AWS SAM](building-layers.md)
# Creazione di funzioni Lambda Node.js con esbuild in AWS SAM
Per creare e impacchettare AWS Lambda le funzioni Node.js, puoi usarle AWS SAMCLI con il bundler esbuild JavaScript . Il bundler esbuild supporta le funzioni Lambda in cui scrivi. TypeScript
Per creare una funzione Lambda Node.js con esbuild, aggiungi un `Metadata` oggetto alla tua `AWS:Serverless::Function` risorsa e specifica `esbuild` per. `BuildMethod` Quando esegui il **sam build** comando, AWS SAM usa esbuild per raggruppare il codice della funzione Lambda.
## Proprietà dei metadati
L'`Metadata`oggetto supporta le seguenti proprietà per esbuild.
### BuildMethod
Specifica il bundler per l'applicazione. L’unico valore supportato è `esbuild`.
### BuildProperties
Specifica le proprietà di compilazione per il codice della funzione Lambda.
L'`BuildProperties`oggetto supporta le seguenti proprietà per esbuild. Tutte le proprietà sono opzionali. Per impostazione predefinita, AWS SAM utilizza il gestore di funzioni Lambda per il punto di ingresso.
**EntryPoints**
Specifica i punti di ingresso per l'applicazione.
**Esterno**
Specifica l'elenco dei pacchetti da omettere dalla compilazione. *Per ulteriori informazioni, consulta [External](https://esbuild.github.io/api/#external) nel sito Web. esbuild*
**Formato**
Specificate il formato di output dei JavaScript file generati nell'applicazione. Per ulteriori informazioni, consulta [Format](https://esbuild.github.io/api/#format) nel sito web *esbuild*.
**Loader**
Specifica l'elenco delle configurazioni per il caricamento dei dati per un determinato tipo di file.
**MainFields**
Speciifica quali `package.json` campi provare a importare durante la risoluzione di un pacchetto. Il valore predefinito è `main,module`.
**Minimizza**
Specifica se minimizzare il codice di output in bundle. Il valore predefinito è `true`.
**OutExtension**
Personalizza l'estensione dei file generati da esbuild. Per ulteriori informazioni, consulta [l'estensione Out](https://esbuild.github.io/api/#out-extension) nel sito Web di *esbuild*.
**Mappa dei sorgenti**
Speciifica se il bundler produce un file di mappa sorgente. Il valore predefinito è `false`.
Se impostato su`true`, `NODE_OPTIONS: --enable-source-maps` viene aggiunto alle variabili di ambiente della funzione Lambda e viene generata e inclusa nella funzione una mappa di origine.
In alternativa, quando `NODE_OPTIONS: --enable-source-maps` è incluso nelle variabili di ambiente della funzione, `Sourcemap` viene impostato automaticamente su. `true`
In caso di conflitto, ha `Sourcemap: false` la precedenza su. `NODE_OPTIONS: --enable-source-maps`
Per impostazione predefinita, Lambda crittografa tutte le variabili di ambiente inattive con AWS Key Management Service ().AWS KMS Quando si utilizzano mappe di origine, affinché la distribuzione abbia esito positivo, il ruolo di esecuzione della funzione deve disporre dell'autorizzazione per eseguire l'`kms:Encrypt`azione.
**SourcesContent**
Speciifica se includere il codice sorgente nel file della mappa di origine. Configura questa proprietà quando `Sourcemap` è impostata su. `'true'`
+ `SourcesContent: 'true'`Specificare di includere tutto il codice sorgente.
+ `SourcesContent: 'false'`Specificare di escludere tutto il codice sorgente. Ciò si traduce in una riduzione delle dimensioni dei file delle mappe di origine, utili nella produzione in quanto riducono i tempi di avvio. Tuttavia, il codice sorgente non sarà disponibile nel debugger.
Il valore predefinito è `SourcesContent: true`.
*Per ulteriori informazioni, consulta il [contenuto di Sources nel sito Web](https://esbuild.github.io/api/#sources-content) di esbuild.*
**Target**
Specifica la versione di destinazione ECMAScript . Il valore predefinito è `es2020`.
## TypeScript Esempio di funzione Lambda
Il seguente frammento di AWS SAM modello di esempio utilizza esbuild per creare una funzione Lambda Node.js dal codice in. TypeScript `hello-world/app.ts`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# Creazione di funzioni.NET Lambda con la compilazione AOT nativa in AWS SAM
Crea e impacchetta le tue AWS Lambda funzioni.NET 8 con AWS Serverless Application Model (AWS SAM), utilizzando la compilazione Native Ahead-of-Time (AOT) per migliorare i tempi di avvio a freddo. AWS Lambda
**Topics**
+ [Panoramica su AOT nativo.NET 8](#build-dotnet7-overview)
+ [Utilizzo AWS SAM con le funzioni Lambda di.NET 8](#build-dotnet7-sam)
+ [Prerequisiti di installazione](#build-dotnet7-prerequisites)
+ [Definisci le funzioni.NET 8 Lambda nel tuo modello AWS SAM](#build-dotnet7-sam-define)
+ [Crea la tua applicazione con AWS SAMCLI](#build-dotnet7-sam-build)
+ [Ulteriori informazioni](#build-dotnet7-learn-more)
## Panoramica su AOT nativo.NET 8
Storicamente, le funzioni.NET Lambda hanno tempi di avvio a freddo che influiscono sull'esperienza utente, sulla latenza del sistema e sui costi di utilizzo delle applicazioni serverless. Con la compilazione AOT nativa.NET, puoi migliorare i tempi di avvio a freddo delle tue funzioni Lambda. *Per ulteriori informazioni su Native AOT for .NET 8, consulta Using [Native AOT nel repository Dotnet](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme). GitHub *
## Utilizzo AWS SAM con le funzioni Lambda di.NET 8
Effettua le seguenti operazioni per configurare le funzioni Lambda di.NET 8 con AWS Serverless Application Model ()AWS SAM:
+ Installa i prerequisiti sulla tua macchina di sviluppo.
+ Definisci le funzioni.NET 8 Lambda nel tuo AWS SAM modello.
+ Crea la tua applicazione con. AWS SAMCLI
## Prerequisiti di installazione
I seguenti sono i prerequisiti obbligatori:
+ Il AWS SAMCLI
+ La CLI.NET Core
+ Lo strumento globale.NET Core di Amazon.Lambda.Tools
+ Docker
**Installa il AWS SAMCLI**
1. Per verificare se è già AWS SAMCLI installato, esegui quanto segue:
```
sam --version
```
1. Per installare AWS SAMCLI, vedere[Installa il AWS SAMCLI](install-sam-cli.md).
1. Per aggiornare una versione installata di AWS SAMCLI, vedere[Aggiornamento del AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).
**Installazione di.NET Core CLI**
1. Per scaricare e installare il.NET Core CLI, vedi [Scaricare.NET dal sito](https://dotnet.microsoft.com/download) Web di Microsoft.
1. *Per ulteriori informazioni su .NET Core CLI, [consulta.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) nella Developer Guide.AWS Lambda *
**Installa lo strumento globale Amazon.Lambda.Tools .NET Core**
1. Esegui il comando seguente:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Se lo strumento è già stato installato, è possibile verificare di avere in uso la versione più recente con il comando seguente:
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Per ulteriori informazioni sullo strumento globale Amazon.Lambda.Tools .NET Core, consulta l'archivio Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI su. GitHub
**Installazione di Docker**
+ La creazione con Native AOT richiede l'installazione. Docker Per le istruzioni di installazione, consulta [Installazione di Docker da utilizzare con AWS SAMCLI](install-docker.md).
## Definisci le funzioni.NET 8 Lambda nel tuo modello AWS SAM
Per definire un. NET8 Funzione Lambda nel AWS SAM modello, procedi come segue:
1. Esegui il comando seguente da una directory iniziale a tua scelta:
```
sam init
```
1. Seleziona `AWS Quick Start Templates` per scegliere un modello di partenza.
1. Scegli il `Hello World Example` modello.
1. Scegli di non utilizzare il runtime e il tipo di pacchetto più diffusi inserendo`n`.
1. Per il runtime, scegliete`dotnet8`.
1. Per il tipo di pacchetto, scegli`Zip`.
1. Per il tuo modello iniziale, scegli`Hello World Example using native AOT`.
**Installazione di Docker**
+ La creazione con Native AOT richiede Docker l'installazione. Per le istruzioni di installazione, consulta [Installazione di Docker da utilizzare con AWS SAMCLI](install-docker.md).
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**Nota**
Quando la `Event` proprietà di an `AWS::Serverless::Function` è impostata su`Api`, ma la `RestApiId` proprietà non è specificata, AWS SAM genera la `AWS::ApiGateway::RestApi` CloudFormation risorsa.
## Crea la tua applicazione con AWS SAMCLI
Dalla directory principale del progetto, esegui il `sam build` comando per iniziare a creare l'applicazione. Se la `PublishAot` proprietà è stata definita nel file di progetto.NET 8, AWS SAMCLI verrà creata con la compilazione AOT nativa. *Per ulteriori informazioni sulla `PublishAot` proprietà, consulta [Native AOT Deployment nella documentazione .NET](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) di Microsoft.*
Per creare la tua funzione, AWS SAMCLI richiama la CLI.NET Core che utilizza lo strumento globale Amazon.Lambda.Tools .NET Core.
**Nota**
Durante la creazione, se un `.sln` file esiste nella stessa directory o nella directory principale del progetto, la directory contenente il file verrà montata nel contenitore. `.sln` Se non viene trovato un `.sln` file, viene montata solo la cartella del progetto. Pertanto, se state creando un'applicazione multiprogetto, assicuratevi che il `.sln` file sia posizionato correttamente.
## Ulteriori informazioni
Per ulteriori informazioni sulla creazione di funzioni.NET 8 Lambda, vedere [Introduzione al runtime di.NET 8](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/) per. AWS Lambda
Per un riferimento al **sam build** comando, vedere[sam build](sam-cli-command-reference-sam-build.md).
# Creazione di funzioni Rust Lambda con in Cargo Lambda AWS SAM
| |
| --- |
| Questa funzionalità è disponibile in anteprima AWS SAM ed è soggetta a modifiche. |
Usa l'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) con le tue AWS Lambda funzioni Rust.
**Topics**
+ [Prerequisiti](#building-rust-prerequisites)
+ [Configurazione AWS SAM per l'uso con le funzioni Rust Lambda](#building-rust-configure)
+ [Esempi](#building-rust-examples)
## Prerequisiti
**Rustlingua**
Per l'installazioneRust, consulta [il sito Web Installa Rust](https://www.rust-lang.org/tools/install) *nella Rust lingua*.
**Cargo Lambda**
AWS SAMCLIRichiede l'installazione di [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), un sottocomando perCargo. Per le istruzioni di installazione, vedere [Installazione](https://www.cargo-lambda.info/guide/installation.html) nella *Cargo Lambdadocumentazione*.
**Docker**
La creazione e il test delle funzioni Rust Lambda richiedono. Docker Per le istruzioni di installazione, consulta [Installazione di Docker](install-docker.md).
**Attiva la funzionalità AWS SAMCLI beta**
Poiché questa funzionalità è disponibile in anteprima, devi attivarla utilizzando uno dei seguenti metodi:
1. Usa la variabile di ambiente:`SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Aggiungi il codice seguente al file `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Usa l'`--beta-features`opzione quando usi un AWS SAMCLI comando supportato. Esempio:
```
$ sam build --beta-features
```
1. Scegli l'opzione `y` quando AWS SAMCLI ti viene richiesto di aderire. Di seguito è riportato un esempio:
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configurazione AWS SAM per l'uso con le funzioni Rust Lambda
### Fase 1: Configura il modello AWS SAM
Configura il tuo AWS SAM modello con quanto segue:
+ **Binario**: facoltativo. Specificate quando il modello contiene più funzioni Rust Lambda.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— percorso del `Cargo.toml` file.
+ **Gestore** —`bootstrap`.
+ **Durata** —`provided.al2`.
Per ulteriori informazioni sui runtime personalizzati, consulta la sezione [AWS Lambda Runtime personalizzati](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) nella *AWS Lambda Developer* Guide.
Ecco un esempio di modello AWS SAM configurato:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### Passaggio 2: utilizzare la funzione Lambda AWS SAMCLI con Rust
Usa qualsiasi AWS SAMCLI comando con il tuo AWS SAM modello. Per ulteriori informazioni, consulta [AWS SAM CLI](using-sam-cli.md).
## Esempi
### Esempio di Hello World
**In questo esempio, creiamo l'applicazione Hello World di esempio utilizzando Rust come runtime.**
Innanzitutto, inizializziamo una nuova applicazione serverless utilizzando. `sam init` Durante il flusso interattivo, selezioniamo l'**applicazione Hello World** e scegliamo il runtime **Rust**.
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
Di seguito è riportata la struttura della nostra applicazione Hello World:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
Nel nostro AWS SAM modello, la nostra Rust funzione è definita come segue:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
Successivamente, `sam build` eseguiamo la creazione della nostra applicazione e ci prepariamo per la distribuzione. AWS SAMCLICrea una `.aws-sam` directory e vi organizza i nostri artefatti di compilazione. La nostra funzione è creata utilizzando Cargo Lambda e archiviata come binario eseguibile in. `.aws-sam/build/HelloWorldFunction/bootstrap`
**Nota**
Se prevedi di eseguire il **sam local invoke** comando in macOS, devi creare funzioni diverse prima di richiamarlo. Per fare ciò, usa il seguente comando:
**SAM\$1BUILD\$1MODE=debug sam build**
Questo comando è necessario solo se verranno eseguiti test locali. Questo non è consigliato quando si crea per la distribuzione.
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
Successivamente, distribuiamo la nostra applicazione utilizzando`sam deploy --guided`.
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
Per testare, possiamo richiamare la nostra funzione Lambda utilizzando l'endpoint API.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Per testare la nostra funzione localmente, per prima cosa ci assicuriamo che la `Architectures` proprietà della nostra funzione corrisponda al nostro computer locale.
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
Poiché `arm64` in questo esempio abbiamo modificato la nostra architettura dalla `x86_64` a alla, `sam build` eseguiamo l'aggiornamento dei nostri artefatti di build. Quindi eseguiamo per `sam local invoke` richiamare localmente la nostra funzione.
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### Progetto a singola funzione Lambda
**Ecco un esempio di applicazione serverless contenente una funzione Rust Lambda.**
Struttura delle cartelle del progetto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM modello:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### Progetto con più funzioni Lambda
**Ecco un esempio di applicazione serverless contenente più funzioni Rust Lambda.**
Struttura delle cartelle del progetto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM modello:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
`Cargo.toml` file
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# Creazione di funzioni Lambda in Python con in uv AWS SAM
| |
| --- |
| Questa funzionalità è disponibile in anteprima AWS SAM ed è soggetta a modifiche. |
Usa la AWS Serverless Application Model Command Line Interface (AWS SAMCLI) conuv, un programma di installazione e risoluzione di pacchetti Python veloce, per creare le tue funzioni Python. AWS Lambda
**Topics**
+ [Prerequisiti](#building-python-uv-prerequisites)
+ [Configurazione AWS SAM per l'uso con le funzioni Python Lambda e uv](#building-python-uv-configure)
+ [Esempi](#building-python-uv-examples)
## Prerequisiti
**Python**
*Per installare Python, consulta Download [Python nel sito Web Python](https://www.python.org/downloads/).*
**uv**
AWS SAMCLIRichiede l'installazione di [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/), un programma di installazione e risoluzione di pacchetti Python estremamente veloce. *Per le istruzioni di installazione, vedete [Installazione](https://docs.astral.sh/uv/getting-started/installation/) nella documentazione. uv*
**Attiva la funzionalità AWS SAMCLI beta**
Poiché questa funzionalità è disponibile in anteprima, devi attivarla utilizzando uno dei seguenti metodi:
1. Usa la variabile di ambiente:`SAM_CLI_BETA_PYTHON_UV=1`.
1. Aggiungi il codice seguente al file `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Usa l'`--beta-features`opzione quando usi un AWS SAMCLI comando supportato. Esempio:
```
$ sam build --beta-features
```
1. Scegli l'opzione `y` quando AWS SAMCLI ti viene richiesto di aderire. Di seguito è riportato un esempio:
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configurazione AWS SAM per l'uso con le funzioni Python Lambda e uv
### Passaggio 1: configura il tuo AWS SAM modello
Configura il tuo AWS SAM modello con quanto segue:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— percorso della directory del codice della funzione contenente `pyproject.toml` o`requirements.txt`.
+ **Handler**: il tuo gestore di funzioni (ad es.). `app.lambda_handler`
+ **Runtime** — Versione runtime di Python (ad es.). `python3.12`
Ecco un esempio di AWS SAM modello configurato:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## Esempi
### Esempio di Hello World
**In questo esempio, creiamo un'applicazione Hello World di esempio usando Python uv come gestore di pacchetti.**
uvpuò usare uno o l'altro `pyproject.toml` o `requirements.txt` leggere le dipendenze. Se vengono forniti entrambi, `sam build` leggerà da `requirements.txt` per verificare le dipendenze.
Di seguito è riportata la struttura della nostra applicazione Hello World:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
`pyproject.toml` file
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
Nel nostro AWS SAM modello, la nostra funzione Python è definita come segue:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
Successivamente, `sam build` eseguiamo la creazione della nostra applicazione e la preparazione per la distribuzione. AWS SAMCLICrea una `.aws-sam` directory e vi organizza i nostri artefatti di compilazione. Le nostre dipendenze dalle funzioni vengono installate utilizzando uv e archiviate in. `.aws-sam/build/HelloWorldFunction/`
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**Nota**
Il metodo di `python-uv` compilazione è configurato per funzione nella `Metadata` sezione. Ogni funzione del modello può utilizzare un metodo di compilazione diverso, che consente di combinare funzioni uv `pip` basate con funzioni basate nello stesso AWS SAM modello. Se non viene specificato alcun metodo di compilazione, `pip` viene utilizzato per impostazione predefinita.
# Creazione di funzioni Lambda con runtime personalizzati in AWS SAM
Puoi usare il `sam build` comando per creare i runtime personalizzati richiesti per la tua funzione Lambda. Dichiari che la tua funzione Lambda utilizzi un runtime personalizzato `Runtime: provided` specificando la funzione.
Per creare un runtime personalizzato, dichiarate l'attributo `Metadata` resource con una voce. `BuildMethod: makefile` Fornisci un makefile personalizzato, in cui dichiari un obiettivo di compilazione del modulo `build-function-logical-id` che contiene i comandi di build per il tuo runtime. Il makefile è responsabile della compilazione del runtime personalizzato, se necessario, e della copia degli elementi di compilazione nella posizione corretta richiesta per le fasi successive del flusso di lavoro. La posizione del makefile è specificata dalla `CodeUri` proprietà della risorsa della funzione e deve essere denominata. `Makefile`
## Esempi
### Esempio 1: runtime personalizzato per una funzione scritta in Rust
**Nota**
Consigliamo di creare funzioni Lambda con. Cargo Lambda Per ulteriori informazioni, consulta [Creazione di funzioni Rust Lambda con in Cargo Lambda AWS SAM](building-rust.md).
Il AWS SAM modello seguente dichiara una funzione che utilizza un runtime personalizzato per una funzione Lambda scritta in Rust e `sam build` indica di eseguire i comandi per `build-HelloRustFunction` l'obiettivo di compilazione.
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
Il seguente makefile contiene l'obiettivo di compilazione e i comandi che verranno eseguiti. Nota che la `CodeUri` proprietà è impostata su`.`, quindi il makefile deve trovarsi nella directory principale del progetto (ovvero, la stessa directory del file AWS SAM modello dell'applicazione). Il nome del file deve essere. `Makefile`
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Per ulteriori informazioni sulla configurazione dell'ambiente di sviluppo per l'esecuzione del `cargo build` comando precedente`makefile`, consultate il AWS Lambda post sul blog di [Rust Runtime for](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Esempio 2: Makefile builder per Python3.12 (alternativa all'utilizzo del builder in bundle)
Potresti voler usare una libreria o un modulo che non è incluso in un builder in bundle. Questo esempio mostra un AWS SAM modello per un runtime Python3.12 con un generatore di makefile.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
Il seguente makefile contiene l'obiettivo di compilazione e i comandi che verranno eseguiti. Nota che la `CodeUri` proprietà è impostata su`hello_world`, quindi il makefile deve trovarsi nella radice della `hello_world` sottodirectory e il nome del file deve essere. `Makefile`
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# Creazione di livelli Lambda in AWS SAM
Puoi usarlo AWS SAM per creare layer Lambda personalizzati. I layer Lambda consentono di estrarre codice da una funzione Lambda che può quindi essere riutilizzato in diverse funzioni Lambda. La creazione di soli livelli Lambda (anziché la creazione dell'intera applicazione) può apportare vantaggi in alcuni modi. Può aiutarvi a ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e consentire di condividere le dipendenze tra più funzioni. Per informazioni sui livelli, consulta i [layer AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) nella *AWS Lambda Developer* Guide.
## Come creare un layer Lambda in AWS SAM
**Nota**
Prima di poter creare un layer Lambda, devi prima scrivere un layer Lambda nel tuo modello. AWS SAM Per informazioni ed esempi su come eseguire questa operazione, consulta. [Aumenta l'efficienza utilizzando i livelli Lambda con AWS SAM](serverless-sam-cli-layers.md)
Per creare un layer personalizzato, dichiaratelo nel vostro file modello AWS Serverless Application Model (AWS SAM) e includete una sezione dedicata agli attributi `Metadata` delle risorse con una `BuildMethod` voce. I valori validi per `BuildMethod` sono identificatori per un [AWS Lambda runtime](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), o. `makefile` Includi una `BuildArchitecture` voce per specificare le architetture del set di istruzioni supportate dal livello. I valori validi per `BuildArchitecture` le architetture dei [set di istruzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Se lo specificate`makefile`, fornite il makefile personalizzato, in cui dichiarate un obiettivo di compilazione del modulo `build-layer-logical-id` che contiene i comandi di compilazione per il livello. Il makefile è responsabile della compilazione del layer, se necessario, e della copia degli artefatti di compilazione nella posizione corretta richiesta per le fasi successive del flusso di lavoro. La posizione del makefile è specificata dalla `ContentUri` proprietà della risorsa del livello e deve essere denominata. `Makefile`
**Nota**
Quando create un layer personalizzato, la ricerca del codice del layer AWS Lambda dipende dalle variabili di ambiente. I runtime Lambda includono i percorsi nella `/opt` directory in cui viene copiato il codice del layer. La struttura delle cartelle degli artefatti di compilazione del progetto deve corrispondere alla struttura delle cartelle prevista per il runtime in modo da poter trovare il codice del layer personalizzato.
Ad esempio, per Python puoi inserire il codice nella `python/` sottodirectory. Per NodeJS, puoi inserire il codice nella sottodirectory. `nodejs/node_modules/`
*Per ulteriori informazioni, consulta [Inclusione delle dipendenze delle librerie in un livello nella Guida](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) per gli sviluppatori.AWS Lambda *
Di seguito è riportato un esempio di sezione relativa agli attributi `Metadata` delle risorse.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**Nota**
Se non includi la sezione degli attributi `Metadata` delle risorse, AWS SAM non crea il layer. Copia invece gli artefatti di compilazione dalla posizione specificata nella `CodeUri` proprietà della risorsa del livello. Per ulteriori informazioni, vedete la [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi)proprietà del tipo di `AWS::Serverless::LayerVersion` risorsa.
Quando includete la sezione degli attributi `Metadata` delle risorse, potete usare il `sam build` comando per creare il livello, sia come oggetto indipendente che come dipendenza di una AWS Lambda funzione.
+ ****Come oggetto indipendente.**** Potresti voler creare solo l'oggetto layer, ad esempio quando stai testando localmente una modifica al codice del layer e non hai bisogno di creare l'intera applicazione. Per creare il livello in modo indipendente, specificate la risorsa del livello con il `sam build layer-logical-id` comando.
+ **Come dipendenza di una funzione Lambda.** Quando includi l'ID logico di un livello nella `Layers` proprietà di una funzione Lambda nello stesso file AWS SAM modello, il livello è una dipendenza di quella funzione Lambda. Quando quel livello include anche una sezione di attributi di `Metadata` risorsa con una `BuildMethod` voce, si crea il livello creando l'intera applicazione con il `sam build` comando o specificando la risorsa della funzione con il comando. `sam build function-logical-id`
## Esempi
### Esempio di modello 1: crea un livello rispetto all'ambiente di runtime Python 3.12
Il seguente AWS SAM modello di esempio crea un livello rispetto all'ambiente di runtime Python 3.12.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Esempio di modello 2: crea un livello utilizzando un makefile personalizzato
Il seguente AWS SAM modello di esempio utilizza un modello personalizzato `makefile` per creare il layer.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
Quanto segue `makefile` contiene l'obiettivo di compilazione e i comandi che verranno eseguiti. Nota che la `ContentUri` proprietà è impostata su`my_layer`, quindi il makefile deve trovarsi nella radice della `my_layer` sottodirectory e il nome del file deve essere. `Makefile` Nota anche che gli artefatti di compilazione vengono copiati nella `python/` sottodirectory in modo che sia AWS Lambda possibile trovare il codice del livello.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**Nota**
Quando `makefile` viene chiamato, viene attivato il target appropriato e gli artefatti devono essere copiati nella variabile ambientale esposta. `$ARTIFACTS_DIR` [Per ulteriori informazioni, fare riferimento a in. aws-lambda-builders GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md)
### Esempi di comandi sam build
I seguenti `sam build` comandi creano livelli che includono le sezioni degli attributi `Metadata` delle risorse.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```