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à.
# Sviluppa la tua applicazione serverless con AWS SAM
Questa sezione contiene argomenti sulla convalida del AWS SAM modello e sulla creazione di un'applicazione con dipendenze. Contiene anche argomenti sull'utilizzo AWS SAM per determinati casi d'uso, come l'utilizzo dei livelli Lambda, l'uso di applicazioni annidate, il controllo dell'accesso ad API Gateway, l'orchestrazione delle APIs risorse con AWS Step Functions e la firma del codice delle applicazioni. Di seguito sono elencate le tre tappe principali da completare per sviluppare l'applicazione.
**Topics**
+ [
# Crea la tua candidatura in AWS SAM
](using-sam-cli-init.md)
+ [
# Definisci la tua infrastruttura con AWS SAM
](serverless-authoring.md)
+ [
# Crea la tua applicazione con AWS SAM
](serverless-building.md)
# Crea la tua candidatura in AWS SAM
Dopo aver completato la [Guida introduttiva](serverless-getting-started.md) e la lettura[Come usare AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), sarai pronto per creare un AWS SAM progetto nel tuo ambiente di sviluppo. Il tuo AWS SAM progetto servirà come punto di partenza per scrivere la tua applicazione serverless. Per un elenco delle opzioni di AWS SAMCLI `sam init` comando, vedere[sam init](sam-cli-command-reference-sam-init.md).
Il AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam init` fornisce opzioni per inizializzare una nuova applicazione serverless composta da:
+ Un AWS SAM modello per definire il codice dell'infrastruttura.
+ Una struttura di cartelle che organizza l'applicazione.
+ Configurazione per le tue AWS Lambda funzioni.
Per creare un AWS SAM progetto, consulta gli argomenti di queste sezioni.
**Nota**
`sam init`include modelli di progetto per funzioni durevoli nei runtime supportati (TypeScript, Python, Java). Questi modelli forniscono codice di avvio e configurazione per la creazione di applicazioni serverless con stato.
**Topics**
+ [
## Inizializza una nuova applicazione serverless
](#using-sam-cli-init-new)
+ [
## Opzioni per sam init
](#using-sam-cli-init-options)
+ [
## Risoluzione dei problemi
](#using-sam-cli-init-troubleshooting)
+ [
## Esempi
](#using-sam-cli-init-examples)
+ [
## Ulteriori informazioni
](#using-sam-cli-init-learn)
+ [
## Fasi successive
](#w2aac18c11c39)
## Inizializza una nuova applicazione serverless
**Per inizializzare una nuova applicazione serverless utilizzando il AWS SAMCLI**
1. `cd`in una directory iniziale.
1. Esegui quanto segue nella riga di comando:
```
$ sam init
```
1. Ti AWS SAMCLI guiderà attraverso un flusso interattivo per creare una nuova applicazione serverless.
**Nota**
Come descritto in dettaglio[Tutorial: Implementa un'applicazione Hello World con AWS SAM](serverless-getting-started-hello-world.md), questo comando inizializza l'applicazione serverless, creando la directory del progetto. Questa directory conterrà diversi file e cartelle. Il file più importante è`template.yaml`. Questo è il tuo AWS SAM modello. La tua versione di python deve corrispondere alla versione di python elencata nel `template.yaml` file creato dal **sam init** comando.
### Scegli un modello di partenza
Un *modello* è composto da quanto segue:
1. Un AWS SAM modello per il codice dell'infrastruttura.
1. Una directory di progetto iniziale che organizza i file di progetto. Ad esempio, ciò può includere:
1. Una struttura per il codice della funzione Lambda e le relative dipendenze.
1. Una `events` cartella che contiene eventi di test per i test locali.
1. Una `tests` cartella per supportare i test unitari.
1. Un `samconfig.toml` file per configurare le impostazioni del progetto.
1. Un `ReadMe` file e altri file di base del progetto iniziale.
Di seguito è riportato un esempio di cartella iniziale del progetto:
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
È possibile selezionare da un elenco di *modelli di avvio AWS rapido* disponibili o fornire una *posizione personalizzata per i modelli*.
**Per scegliere un modello di avvio AWS rapido**
1. Quando richiesto, seleziona **Modelli di avvio AWS rapido**.
1. Seleziona un modello AWS Quick Start con cui iniziare. Di seguito è riportato un esempio:
```
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
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 4
```
**Per scegliere la posizione del modello personalizzata**
1. Quando richiesto, seleziona la **posizione del modello personalizzato**.
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. Ti AWS SAMCLI verrà chiesto di fornire una posizione per il modello.
```
Template location (git, mercurial, http(s), zip, path):
```
Fornisci una delle seguenti posizioni all'archivio del file.zip del modello:
+ **GitHubrepository**: il percorso del file.zip nel tuo repository. GitHub Il file deve trovarsi nella cartella principale del repository.
+ **Mercurialrepository**: il percorso del file.zip nel tuo repository. Mercurial Il file deve trovarsi nella cartella principale del repository.
+ **Percorso.zip**: un percorso HTTPS o locale del file.zip.
1. AWS SAMCLIInizializzerà l'applicazione serverless utilizzando il modello personalizzato.
### Scegli un runtime
Quando scegli un *modello AWS Quick Start*, AWS SAMCLI ti viene richiesto di selezionare un runtime per le tue funzioni Lambda. L'elenco di opzioni visualizzato da AWS SAMCLI sono i runtime supportati nativamente da Lambda.
+ Il [runtime](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) fornisce un ambiente specifico del linguaggio di programmazione che viene eseguito in un ambiente di esecuzione.
+ [Quando viene distribuito su Cloud AWS, il servizio Lambda richiama la funzione in un ambiente di esecuzione.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)
È possibile utilizzare qualsiasi altro linguaggio di programmazione con un runtime personalizzato. A tale scopo, è necessario creare manualmente la struttura dell'applicazione iniziale. È quindi possibile utilizzarla `sam init` per inizializzare rapidamente l'applicazione configurando una posizione personalizzata del modello.
Dalla selezione, AWS SAMCLI crea la directory iniziale per il codice della funzione Lambda e le dipendenze.
Se Lambda supporta più gestori delle dipendenze per il tuo runtime, ti verrà richiesto di scegliere il tuo gestore delle dipendenze preferito.
### Scegli un tipo di pacchetto
Quando si sceglie un *modello di avvio AWS rapido* e un *runtime*, viene AWS SAMCLI richiesto di selezionare un tipo di *pacchetto*. Il tipo di pacchetto determina il modo in cui le funzioni Lambda vengono distribuite per l'uso con il servizio Lambda. I due tipi di pacchetto supportati sono:
1. **Immagine del contenitore**: contiene il sistema operativo di base, il runtime, le estensioni Lambda, il codice dell'applicazione e le relative dipendenze.
1. **Archivio di file.zip**: contiene il codice dell'applicazione e le relative dipendenze.
Per ulteriori informazioni sui tipi di pacchetti di distribuzione, consulta i [pacchetti di distribuzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) nella *AWS Lambda Developer* Guide.
Di seguito è riportato un esempio di struttura di directory di un'applicazione con una funzione Lambda impacchettata come immagine contenitore. AWS SAMCLIScarica l'immagine e ne crea una `Dockerfile` nella directory della funzione per specificare l'immagine.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
Di seguito è riportato un esempio di struttura di directory di un'applicazione con una funzione impacchettata come archivio di file.zip.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### Configura il tracciamento AWS X-Ray
È possibile scegliere di attivare il AWS X-Ray tracciamento. Per ulteriori informazioni, vedi [Cos'è AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) nella *Guida per gli AWS X-Ray sviluppatori*.
Se si attiva, AWS SAMCLI configura il AWS SAM modello. Di seguito è riportato un esempio:
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Configura il monitoraggio con Amazon CloudWatch Application Insights
Puoi scegliere di attivare il monitoraggio utilizzando Amazon CloudWatch Application Insights. Per ulteriori informazioni, consulta [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) nella *Amazon CloudWatch User Guide*.
Se lo attivi, AWS SAMCLI configura il tuo AWS SAM modello. Di seguito è riportato un esempio:
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### Assegna un nome all'applicazione
Fornisci un nome per la tua candidatura. AWS SAMCLICrea una cartella di primo livello per l'applicazione utilizzando questo nome.
## Opzioni per sam init
Di seguito sono riportate alcune delle opzioni principali che è possibile utilizzare con il `sam init` comando. Per un elenco di tutte le opzioni, vedere[sam init](sam-cli-command-reference-sam-init.md).
### Inizializza un'applicazione utilizzando una posizione personalizzata del modello
Utilizza l'`--location`opzione e fornisci una posizione del modello personalizzata supportata. Di seguito è riportato un esempio:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### Inizializza un'applicazione senza il flusso interattivo
Utilizza l'`--no-interactive`opzione e fornisci le tue scelte di configurazione nella riga di comando per saltare il flusso interattivo. Di seguito è riportato un esempio:
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## Risoluzione dei problemi
Per risolvere il problema, consulta. AWS SAMCLI [AWS SAMCLIrisoluzione dei problemi](sam-cli-troubleshooting.md)
## Esempi
### Inizializza una nuova applicazione serverless utilizzando il modello Hello World Starter AWS
Per questo esempio, vedi [Passaggio 1: inizializza l'applicazione Hello World di esempio](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) in *Tutorial: Deploying a Hello World application*.
### Inizializza una nuova applicazione serverless con una posizione del modello personalizzata
Di seguito sono riportati alcuni esempi di come fornire una GitHub posizione al modello personalizzato:
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
Di seguito è riportato un esempio di percorso di file locale:
```
$ sam init --location /path/to/template.zip
```
Di seguito è riportato un esempio di percorso raggiungibile tramite HTTPS:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## Ulteriori informazioni
Per ulteriori informazioni sull'utilizzo del `sam init` comando, consulta quanto segue:
+ **[Apprendimento AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — Serie Serverless Land «Learning AWS SAM» suYouTube.
+ **[Strutturazione di applicazioni serverless da utilizzare con AWS SAMCLI (Sessions with SAM S2E7) — Sessioni](https://www.youtube.com/watch?v=k9IRdgze9fQ)** con serie attivate. AWS SAM YouTube
## Fasi successive
Ora che hai creato il tuo AWS SAM progetto, sei pronto per iniziare a creare la tua applicazione. [Definisci la tua infrastruttura con AWS SAM](serverless-authoring.md)Per eseguire questa operazione, consultate le istruzioni dettagliate sulle attività da completare.
# Definisci la tua infrastruttura con AWS SAM
Ora che hai creato il tuo progetto, sei pronto per definire la tua infrastruttura applicativa con AWS SAM. A tale scopo, configurate il AWS SAM modello per definire le risorse e le proprietà dell'applicazione, ovvero il `template.yaml` file del AWS SAM progetto.
Gli argomenti di questa sezione forniscono contenuti sulla definizione dell'infrastruttura nel AWS SAM modello (il `template.yaml` file). Contiene anche argomenti sulla definizione delle risorse per casi d'uso specifici, come l'utilizzo dei livelli Lambda, l'utilizzo di applicazioni annidate, il controllo dell'accesso ad API Gateway, l'orchestrazione delle risorse con AWS Step Functions APIs, la firma del codice delle applicazioni e la convalida del modello. AWS SAM
**Topics**
+ [
# Definisci le risorse dell'applicazione nel tuo AWS SAM modello
](authoring-define-resources.md)
+ [
# Configura e gestisci l'accesso alle risorse nel tuo AWS SAM modello
](sam-permissions.md)
+ [
# Controlla l'accesso alle API con il tuo AWS SAM modello
](serverless-controlling-access-to-apis.md)
+ [
# Aumenta l'efficienza utilizzando i livelli Lambda con AWS SAM
](serverless-sam-cli-layers.md)
+ [
# Riutilizza codice e risorse utilizzando applicazioni annidate in AWS SAM
](serverless-sam-template-nested-applications.md)
+ [
# Gestisci eventi basati sul tempo con EventBridge Scheduler in AWS SAM
](using-eventbridge-scheduler.md)
+ [
# Orchestrazione delle risorse con AWS SAM AWS Step Functions
](serverless-step-functions-in-sam.md)
+ [
# Configura la firma del codice per la tua AWS SAM applicazione
](authoring-codesigning.md)
+ [
# Convalida dei file AWS SAM modello
](serverless-sam-cli-using-validate.md)
# Definisci le risorse dell'applicazione nel tuo AWS SAM modello
Definisci le AWS risorse utilizzate dall'applicazione serverless nella `Resources` sezione del AWS SAM modello. Quando si definisce una risorsa, si identifica cos'è la risorsa, come interagisce con altre risorse e in che modo è possibile accedervi (ovvero le autorizzazioni della risorsa).
La `Resources` sezione del AWS SAM modello può contenere una combinazione di CloudFormation risorse e AWS SAM risorse. Inoltre, puoi utilizzare AWS SAM la sintassi abbreviata per le seguenti risorse:
| AWS SAM sintassi abbreviata | Cosa fa con una risorsa correlata AWS |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | Crea una raccolta di risorse e metodi API Gateway che possono essere richiamati tramite endpoint HTTPS. |
| [AWS::Serverless::Application](sam-resource-application.md) | Incorpora un'applicazione serverless da [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications)o da un bucket Amazon S3 come applicazione annidata. |
| [AWS::Serverless::Connector](sam-resource-connector.md) | Configura le autorizzazioni tra due risorse. Per un'introduzione ai connettori, vedere. [Gestione delle autorizzazioni delle risorse con i connettori AWS SAM](managing-permissions-connectors.md) |
| [AWS::Serverless::Function](sam-resource-function.md) | Crea una AWS Lambda funzione, un ruolo di esecuzione AWS Identity and Access Management (IAM) e mappature delle sorgenti degli eventi che attivano la funzione. |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | crea e configura un' AWS AppSync GraphQLAPI per la tua applicazione serverless. |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Crea un'API HTTP Amazon API Gateway, che ti consente di creare RESTful APIs con una latenza inferiore e costi inferiori rispetto a REST APIs. |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Crea una Lambda LayerVersion che contiene il codice di libreria o di runtime necessario per una funzione Lambda. |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Crea una tabella DynamoDB con una chiave primaria a singolo attributo. |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Crea una macchina a AWS Step Functions stati, che puoi utilizzare per orchestrare AWS Lambda funzioni e altre AWS risorse per formare flussi di lavoro complessi e robusti. |
Le risorse di cui sopra sono elencate anche in. [AWS SAM risorse e proprietà](sam-specification-resources-and-properties.md)
Per informazioni di riferimento per tutti i tipi di AWS risorse e proprietà CloudFormation e il AWS SAM supporto, vedere il [riferimento ai tipi di AWS risorse e proprietà](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) nella *Guida per l'AWS CloudFormation utente*.
# Configura e gestisci l'accesso alle risorse nel tuo AWS SAM modello
Affinché le AWS risorse interagiscano tra loro, è necessario configurare l'accesso e le autorizzazioni corretti tra le risorse. A tale scopo è necessaria la configurazione di utenti, ruoli e policy AWS Identity and Access Management (IAM) per realizzare l'interazione in modo sicuro.
Gli argomenti di questa sezione sono tutti relativi alla configurazione dell'accesso alle risorse definite nel modello. Questa sezione inizia con le migliori pratiche generali. Nei due argomenti successivi vengono esaminate due opzioni disponibili per configurare l'accesso e le autorizzazioni tra le risorse a cui fa riferimento l'applicazione serverless: AWS SAM connettori e AWS SAM modelli di policy. L'ultimo argomento fornisce dettagli per la gestione dell'accesso degli utenti utilizzando gli stessi meccanismi CloudFormation utilizzati per la gestione degli utenti.
Per ulteriori informazioni, consulta [Controllare l'accesso con AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) nella *Guida per l'AWS CloudFormation utente*.
La AWS Serverless Application Model (AWS SAM) offre due opzioni che semplificano la gestione degli accessi e delle autorizzazioni per le applicazioni serverless.
1. AWS SAM connettori
1. AWS SAM modelli di policy
## AWS SAM connettori
I connettori sono un modo per fornire autorizzazioni tra due risorse. A tale scopo, descrivi come devono interagire tra loro nel modello. AWS SAM Possono essere definiti utilizzando l'attributo di `Connectors` risorsa o il tipo di `AWS::Serverless::Connector` risorsa. I connettori supportano la fornitura `Read` e `Write` l'accesso a dati ed eventi tra una combinazione di AWS risorse. Per ulteriori informazioni sui AWS SAM connettori, consulta[Gestione delle autorizzazioni delle risorse con i connettori AWS SAM](managing-permissions-connectors.md).
## AWS SAM modelli di policy
AWS SAM i modelli di policy sono set di autorizzazioni predefiniti che è possibile aggiungere ai AWS SAM modelli per gestire l'accesso e le autorizzazioni tra le AWS Lambda funzioni, le macchine a AWS Step Functions stati e le risorse con cui interagiscono. Per ulteriori informazioni sui modelli di AWS SAM policy, consulta. [AWS SAM modelli di policy](serverless-policy-templates.md)
## AWS CloudFormation meccanismi
CloudFormation i meccanismi includono la configurazione di utenti, ruoli e policy IAM per gestire le autorizzazioni tra le AWS risorse. Per ulteriori informazioni, consulta [Gestione delle AWS SAM autorizzazioni con meccanismi CloudFormation](sam-permissions-cloudformation.md).
## Best practice
Nelle tue applicazioni serverless, puoi utilizzare diversi metodi per configurare le autorizzazioni tra le tue risorse. Pertanto, è possibile selezionare l'opzione migliore per ogni scenario e utilizzare più opzioni contemporaneamente in tutte le applicazioni. Ecco alcuni aspetti da considerare quando si sceglie l'opzione migliore per voi:
+ AWS SAM i connettori e i modelli di policy riducono entrambi le competenze IAM necessarie per facilitare le interazioni sicure tra le AWS risorse. Utilizza connettori e modelli di policy se supportati.
+ AWS SAM i connettori forniscono una sintassi abbreviata semplice e intuitiva per definire le autorizzazioni nei AWS SAM modelli e richiedono la minima esperienza in materia di IAM. Quando sono supportati sia i AWS SAM connettori che i modelli di policy, utilizza i connettori. AWS SAM
+ AWS SAM i connettori possono fornire `Read` e `Write` accedere a dati ed eventi tra le risorse di AWS SAM origine e di destinazione supportate. Per un elenco delle risorse supportate, vedere[AWS SAM riferimento del connettore](reference-sam-connector.md). Se supportato, usa i AWS SAM connettori.
+ Sebbene i modelli di AWS SAM policy siano limitati alle autorizzazioni tra le funzioni Lambda, le macchine a stati di Step Functions e AWS le risorse con cui interagiscono, i modelli di policy supportano tutte le operazioni CRUD. Se supportati e quando è disponibile un modello di AWS SAM policy per il tuo scenario, utilizza AWS SAM i modelli di policy. Per un elenco dei modelli di policy disponibili, consulta[AWS SAM modelli di policy](serverless-policy-templates.md).
+ Per tutti gli altri scenari o quando è richiesta la granularità, utilizzate CloudFormation i meccanismi.
# Gestione delle autorizzazioni delle risorse con i connettori AWS SAM
I connettori sono un tipo di risorsa astratto AWS Serverless Application Model (AWS SAM), identificato come`AWS::Serverless::Connector`, che fornisce autorizzazioni semplici e ben definite tra le risorse delle applicazioni serverless.
## Vantaggi dei connettori AWS SAM
Componendo automaticamente le politiche di accesso appropriate tra le risorse, Connectors vi offre la possibilità di creare applicazioni serverless e concentrarvi sull'architettura dell'applicazione senza bisogno di competenze in termini di funzionalità di AWS autorizzazione, linguaggio delle policy e impostazioni di sicurezza specifiche del servizio. Pertanto, i connettori rappresentano un grande vantaggio per gli sviluppatori che potrebbero essere alle prime armi nello sviluppo serverless o per gli sviluppatori esperti che desiderano aumentare la velocità di sviluppo.
## Utilizzo dei connettori AWS SAM
Usa l'attributo `Connectors` resource incorporandolo in una risorsa di **origine**. Quindi, definisci la risorsa di **destinazione** e descrivi come i dati o gli eventi devono fluire tra tali risorse. AWS SAM compone quindi le politiche di accesso necessarie per facilitare le interazioni richieste.
Di seguito viene descritto come viene scritto questo attributo di risorsa:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Come funzionano i connettori
**Nota**
Questa sezione spiega come i connettori forniscono le risorse necessarie dietro le quinte. Ciò avviene automaticamente quando si utilizzano i connettori.
Innanzitutto, l'attributo di `Connectors` risorsa incorporato viene trasformato in un tipo di `AWS::Serverless::Connector` risorsa. Il relativo ID logico viene creato automaticamente come**.
Ad esempio, ecco un connettore incorporato:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Questo genererà la seguente `AWS::Serverless::Connector` risorsa:
```
Transform: AWS::Serverless-2016-10-31
Resources:
...
MyFunctionMyConn:
Type: AWS::Serverless::Connector
Properties:
Source:
Id: MyFunction
Destination:
Id: MyTable
Permissions:
- Read
- Write
```
**Nota**
È inoltre possibile definire i connettori nel AWS SAM modello utilizzando questa sintassi. Questa operazione è consigliata quando la risorsa di origine è definita su un modello separato dal connettore.
Successivamente, le politiche di accesso necessarie per questa connessione vengono composte automaticamente. Per ulteriori informazioni sulle risorse generate dai connettori, vedere[CloudFormation risorse generate quando si specifica AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Esempio di connettori
L'esempio seguente mostra come utilizzare i connettori per scrivere dati da una AWS Lambda funzione a una tabella Amazon DynamoDB.
![\[Una funzione Lambda che scrive dati su una tabella DynamoDB utilizzando connettori. AWS SAM\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyTable:
Type: AWS::Serverless::SimpleTable
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Write
Properties:
Runtime: nodejs16.x
Handler: index.handler
InlineCode: |
const AWS = require("aws-sdk");
const docClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async (event, context) => {
await docClient.put({
TableName: process.env.TABLE_NAME,
Item: {
id: context.awsRequestId,
event: JSON.stringify(event)
}
}).promise();
}
Environment:
Variables:
TABLE_NAME: !Ref MyTable
```
L'attributo `Connectors` resource è incorporato nella risorsa sorgente della funzione Lambda. La tabella DynamoDB è definita come risorsa di destinazione utilizzando la proprietà. `Id` I connettori forniranno le `Write` autorizzazioni tra queste due risorse.
Quando distribuisci il AWS SAM modello su CloudFormation, AWS SAM comporrà automaticamente le politiche di accesso necessarie per il funzionamento di questa connessione.
## Connessioni supportate tra risorse di origine e destinazione
Supportano i connettori `Read` e `Write` i tipi di autorizzazione per dati ed eventi tra una combinazione selezionata di connessioni alle risorse di origine e destinazione. Ad esempio, i connettori supportano una `Write` connessione tra una `AWS::ApiGateway::RestApi` risorsa di origine e una risorsa di `AWS::Lambda::Function` destinazione.
Le risorse di origine e di destinazione possono essere definite utilizzando una combinazione di proprietà supportate. I requisiti delle proprietà dipenderanno dalla connessione che si sta effettuando e da dove vengono definite le risorse.
**Nota**
I connettori possono fornire le autorizzazioni tra i tipi di risorse serverless e non serverless supportati.
Per un elenco delle connessioni di risorse supportate e dei relativi requisiti di proprietà, vedere. [Tipi di risorse di origine e destinazione supportati per i connettori](reference-sam-connector.md#supported-connector-resource-types)
# Definire le autorizzazioni di lettura e scrittura in AWS SAM
In AWS SAM, `Read` e `Write` le autorizzazioni possono essere fornite all'interno di un singolo connettore:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyTableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Per ulteriori informazioni sull'uso dei connettori, fare riferimento a. [AWS SAM riferimento del connettore](reference-sam-connector.md)
# Definire le risorse utilizzando altre proprietà supportate in AWS SAM
Per le risorse di origine e di destinazione, se definite all'interno dello stesso modello, utilizzate la `Id` proprietà. Facoltativamente, `Qualifier` è possibile aggiungere un per restringere l'ambito della risorsa definita. Se la risorsa non si trova all'interno dello stesso modello, utilizzate una combinazione di proprietà supportate.
+ Per un elenco delle combinazioni di proprietà supportate per le risorse di origine e di destinazione, vedere[Tipi di risorse di origine e destinazione supportati per i connettori](reference-sam-connector.md#supported-connector-resource-types).
+ Per una descrizione delle proprietà che è possibile utilizzare con i connettori, vedere[AWS::Serverless::Connector](sam-resource-connector.md).
Quando definite una risorsa di origine con una proprietà diversa da`Id`, utilizzate la `SourceReference` proprietà.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
Ecco un esempio di utilizzo di `Qualifier` a per restringere l'ambito di una risorsa Amazon API Gateway:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyApi:
Type: AWS::Serverless::Api
Connectors:
ApiToLambdaConn:
Properties:
SourceReference:
Qualifier: Prod/GET/foobar
Destination:
Id: MyFunction
Permissions:
- Write
...
```
Ecco un esempio di utilizzo di una combinazione supportata di `Arn` e `Type` per definire una risorsa di destinazione da un altro modello:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
TableConn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
...
```
Per ulteriori informazioni sull'uso dei connettori, fare riferimento a[AWS SAM riferimento del connettore](reference-sam-connector.md).
# Crea più connettori da un'unica fonte in AWS SAM
All'interno di una risorsa di origine, è possibile definire più connettori, ciascuno con una risorsa di destinazione diversa.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
BucketConn:
Properties:
Destination:
Id: amzn-s3-demo-bucket
Permissions:
- Read
- Write
SQSConn:
Properties:
Destination:
Id: MyQueue
Permissions:
- Read
- Write
TableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
TableConnWithTableArn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
Permissions:
- Read
- Write
...
```
Per ulteriori informazioni sull'uso dei connettori, fare riferimento a[AWS SAM riferimento del connettore](reference-sam-connector.md).
# Creare connettori a destinazione multipla in AWS SAM
All'interno di una risorsa di origine, è possibile definire un singolo connettore con più risorse di destinazione. Ecco un esempio di risorsa sorgente di una funzione Lambda che si connette a un bucket Amazon Simple Storage Service (Amazon S3) e a una tabella DynamoDB:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
WriteAccessConn:
Properties:
Destination:
- Id: OutputBucket
- Id: CredentialTable
Permissions:
- Write
...
OutputBucket:
Type: AWS::S3::Bucket
CredentialTable:
Type: AWS::DynamoDB::Table
```
Per ulteriori informazioni sull'uso dei connettori, consulta. [AWS SAM riferimento del connettore](reference-sam-connector.md)
# Definire gli attributi delle risorse con i connettori in AWS SAM
È possibile definire gli attributi delle risorse per specificare comportamenti e relazioni aggiuntivi. Per ulteriori informazioni sugli attributi delle risorse, consulta il [riferimento agli attributi delle risorse](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) nella *Guida per l'AWS CloudFormation utente*.
È possibile aggiungere attributi di risorsa al connettore incorporato definendoli allo stesso livello delle proprietà del connettore. Quando il AWS SAM modello viene trasformato durante la distribuzione, gli attributi passeranno alle risorse generate.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Per ulteriori informazioni sull'uso dei connettori, fare riferimento a[AWS SAM riferimento del connettore](reference-sam-connector.md).
## Ulteriori informazioni
Per ulteriori informazioni sull'uso dei AWS SAM connettori, consulta i seguenti argomenti:
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Definire le autorizzazioni di lettura e scrittura in AWS SAM](connector-usage-define.md)
+ [Definire le risorse utilizzando altre proprietà supportate in AWS SAM](connector-usage-other-properties.md)
+ [Crea più connettori da un'unica fonte in AWS SAM](connector-usage-single-source.md)
+ [Creare connettori a destinazione multipla in AWS SAM](connector-usage-multi-destination.md)
+ [Definire le autorizzazioni di lettura e scrittura in AWS SAM](connector-usage-define.md)
+ [Definire gli attributi delle risorse con i connettori in AWS SAM](connector-usage-resource-attributes.md)
## Rilascio di feedback
Per fornire feedback sui connettori, [invia un nuovo problema](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) al *serverless-application-model AWS GitHubrepository*.
# AWS SAM modelli di policy
Il AWS Serverless Application Model (AWS SAM) consente di scegliere da un elenco di modelli di policy per definire l'ambito delle autorizzazioni delle funzioni Lambda AWS Step Functions e delle macchine a stati per le risorse utilizzate dall'applicazione.
AWS SAM le applicazioni AWS Serverless Application Repository che utilizzano modelli di policy non richiedono alcun riconoscimento speciale da parte dei clienti per distribuire l'applicazione da. AWS Serverless Application Repository
Se desideri richiedere l'aggiunta di un nuovo modello di policy, procedi come segue:
1. Invia una pull request per il file sorgente policy\$1templates.json nel ramo del progetto. `develop` AWS SAM GitHub [Puoi trovare il file sorgente in policy\$1templates.json sul sito web.](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) GitHub
1. Invia un problema nel AWS SAM GitHub progetto che includa i motivi della pull request e un link alla richiesta. Usa questo link per inviare un nuovo numero: [AWS Serverless Application Model: Problemi](https://github.com/aws/serverless-application-model/issues/new).
## Sintassi
Per ogni modello di policy specificato nel file di AWS SAM modello, è necessario specificare sempre un oggetto contenente i valori segnaposto del modello di policy. Se un modello di policy non richiede alcun valore segnaposto, è necessario specificare un oggetto vuoto.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**Nota**
Se hai impostato una normale policy IAM o hai gestito policy tramite Lambda, il modello di policy può essere impostato senza utilizzare un oggetto vuoto.
## Esempi
### Esempio 1: modello di policy con valori placeholder
L'esempio seguente mostra che il modello di policy [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) si aspetta `QueueName` come risorsa. Il AWS SAM modello recupera il nome della coda `MyQueue` "" Amazon SQS, che puoi creare nella stessa applicazione o richiesta come parametro all'applicazione.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - SQSPollerPolicy:
9. QueueName:
10. !GetAtt MyQueue.QueueName
```
### Esempio 2: modello di policy senza valori placeholder
L'esempio seguente contiene il modello di policy [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) senza valori placeholder.
**Nota**
Anche se non sono presenti valori segnaposto, è necessario specificare un oggetto vuoto, altrimenti si verificherà un errore.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Esempio 3: modello di policy con valori segnaposto e una normale policy IAM
L'esempio seguente contiene la policy e [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) il modello di policy di Amazon SQSFull Access. La policy di Amazon SQSFull Access è una policy IAM e non una AWS SAM policy, quindi non è necessario specificare un oggetto vuoto poiché la policy verrebbe passata direttamente a CloudFormation.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
9. - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10. TableName:
11. !Ref SampleTable
```
## Tabella dei modelli di policy
Di seguito è riportata una tabella dei modelli di policy disponibili.
****
| Modello di policy | Description |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Fornisce il permesso di leggere un certificato da AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Autorizza a descrivere Amazon Machine Images (AMIs). |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Fornisce le autorizzazioni per eseguire le query Athena. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Autorizza a ottenere il valore segreto per il segreto specificato. Gestione dei segreti AWS |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Dà il permesso di far ruotare un segreto. Gestione dei segreti AWS |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Dà il permesso di descrivere le CloudFormation pile. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Fornisce le autorizzazioni per inserire le metriche in modo che funzionino nei dashboard. CloudWatch |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Autorizza a descrivere CloudWatch la cronologia degli allarmi. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Autorizza a inviare metriche a. CloudWatch |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Fornisce le autorizzazioni agli create/read/update/delete oggetti all'interno di un repository specifico CodeCommit. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Fornisce le autorizzazioni per leggere oggetti all'interno di un repository specifico. CodeCommit |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Fornisce l'autorizzazione a una funzione Lambda richiamata da CodePipeline per segnalare lo stato del lavoro. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Fornisce il permesso di lettura per ottenere dettagli su una CodePipeline pipeline. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Autorizza il rilevamento di entità, frasi chiave, lingue e sentimenti. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Fornisce l'autorizzazione di sola lettura al Cost APIs Explorer di sola lettura per la cronologia di fatturazione. |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Fornisce l'autorizzazione di lettura e scrittura ai backup su richiesta di DynamoDB per una tabella. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Fornisce autorizzazioni di creazione, lettura, aggiornamento ed eliminazione per una tabella Amazon DynamoDB. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Fornisce l'autorizzazione di sola lettura a una tabella DynamoDB. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Fornisce il permesso di riconfigurare una tabella DynamoDB. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Autorizza il ripristino di una tabella DynamoDB dal backup. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Autorizza a descrivere e leggere i flussi e i record di DynamoDB. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Fornisce l'autorizzazione di sola scrittura a una tabella DynamoDB. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Autorizza a copiare le immagini di Amazon EC2. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Autorizza a descrivere le istanze Amazon Elastic Compute Cloud (Amazon EC2). |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Fornisce il permesso di iniziare una nuova attività per la definizione di un'attività. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Autorizza il montaggio di un file system Amazon EFS con accesso in scrittura. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Autorizza a descrivere o elencare i cluster Amazon EKS. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Autorizza ad aggiungere nuovi passaggi a un cluster in esecuzione. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Autorizza ad annullare uno o più passaggi in sospeso in un cluster in esecuzione. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Autorizza a elencare i dettagli e modificare le capacità, ad esempio le flotte all'interno di un cluster. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Autorizza a elencare i dettagli e modificare le impostazioni per i gruppi di istanze all'interno di un cluster. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Autorizza a impostare la protezione dalla terminazione per un cluster. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Autorizza la chiusura di un cluster. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Fornisce l'autorizzazione POST ad Amazon OpenSearch Service. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Fornisce le autorizzazioni a cui inviare eventi. EventBridge |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Autorizza a filtrare gli eventi di CloudWatch log da un gruppo di log specificato. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Autorizza a creare, scrivere, aggiornare ed eliminare un flusso di distribuzione Firehose. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Autorizza la scrittura su un flusso di distribuzione Firehose. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Autorizza a creare, pubblicare ed eliminare uno stream Amazon Kinesis. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Autorizza a elencare e leggere uno stream Amazon Kinesis. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Autorizza la decrittografia con una chiave AWS Key Management Service ()AWS KMS. |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Dà il permesso di cifrare con una chiave AWS Key Management Service ()AWS KMS. |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Fornisce il permesso di richiamare una AWS Lambda funzione, un alias o una versione. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Fornisce l'autorizzazione di sola scrittura per inserire i dati degli eventi per tutte le risorse dell'applicazione. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Fornisce l'autorizzazione di sola lettura per elencare i nomi degli account secondari e. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Autorizza a ottenere e aggiornare gli endpoint per un'applicazione Amazon Pinpoint. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Fornisce l'autorizzazione di accesso completo alle risorse lessicali di Amazon Polly. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Autorizza il rilevamento di volti, etichette e testo. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Autorizza ad aggiungere, eliminare e cercare volti in una raccolta Amazon Rekognition. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Autorizza a confrontare e rilevare volti ed etichette. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Autorizza il rilevamento degli oggetti e delle etichette di moderazione. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Autorizza a confrontare e rilevare volti ed etichette. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Autorizza a elencare e cercare volti. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Autorizza a creare volti da collezione e da indicizzare. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Autorizza a modificare i set di record di risorse in Route 53. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Fornisce l'autorizzazione di creazione, lettura, aggiornamento ed eliminazione per agire sugli oggetti in un bucket Amazon S3. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Fornisce l'autorizzazione di accesso completa per agire sugli oggetti in un bucket Amazon S3. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Fornisce l'autorizzazione di sola lettura per leggere oggetti in un bucket Amazon Simple Storage Service (Amazon S3). |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Fornisce il permesso di scrittura per scrivere oggetti in un bucket Amazon S3. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Fornisce il permesso di creare una configurazione di endpoint in AI. SageMaker |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Fornisce il permesso di creare un endpoint in SageMaker AI. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Autorizza a creare ed elencare applicazioni nel AWS Serverless Application Repository servizio. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Autorizza l'invio di e-mail, e-mail basate su modelli, e-mail collettive basate su modelli e verifica l'identità. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Autorizza a inviare e-mail Amazon SES, e-mail basate su modelli e e-mail collettive basate su modelli e a verificare l'identità. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Autorizza l'invio di e-mail e la verifica dell'identità. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Autorizza a creare, ottenere, elencare, aggiornare ed eliminare modelli di e-mail Amazon SES. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Fornisce SendBounce l'autorizzazione a un'identità Amazon Simple Email Service (Amazon SES). |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Autorizza a creare, pubblicare e sottoscrivere argomenti di Amazon SNS. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Autorizza a pubblicare un messaggio su un argomento di Amazon Simple Notification Service (Amazon SNS). |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Autorizza il polling di una coda Amazon Simple Queue Service (Amazon SQS). |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Autorizza l'invio di messaggi a una coda Amazon SQS. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Fornisce l'autorizzazione ad accedere a un parametro da un archivio di parametri Amazon EC2 Systems Manager (SSM) per caricare i segreti in questo account. Da utilizzare quando il nome del parametro non ha il prefisso slash. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Fornisce l'autorizzazione ad accedere a un parametro da un archivio di parametri Amazon EC2 Systems Manager (SSM) per caricare i segreti in questo account. Da utilizzare quando il nome del parametro ha un prefisso slash. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Fornisce il permesso di avviare l'esecuzione di una macchina a stati Step Functions. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Fornisce l'accesso per rilevare e analizzare documenti con Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Fornisce l'accesso per ottenere documenti rilevati e analizzati da Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Fornisce accesso completo ad Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Fornisce l'accesso per creare, eliminare, descrivere e scollegare interfacce di rete elastiche. |
## Risoluzione dei problemi
### Errore CLI SAM: «È necessario specificare valori di parametro validi per il modello di policy policy-template-name '< >'»
Durante l'esecuzione di `sam build`, viene visualizzato il seguente errore:
```
"Must specify valid parameter values for policy template ''"
```
Ciò significa che non è stato passato un oggetto vuoto durante la dichiarazione di un modello di policy privo di valori segnaposto.
Per risolvere questo problema, dichiarate la politica come nell'esempio seguente per. [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy)
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM elenco di modelli di policy
Di seguito sono riportati i modelli di policy disponibili, insieme alle autorizzazioni applicate a ciascuno di essi. AWS Serverless Application Model (AWS SAM) compila automaticamente gli elementi segnaposto (come AWS Regione e ID account) con le informazioni appropriate.
**Topics**
+ [
## AcmGetCertificatePolicy
](#acm-get-certificate-policy)
+ [
## AMIDescribePolicy
](#ami-describe-policy)
+ [
## AthenaQueryPolicy
](#athena-query-policy)
+ [
## AWSSecretsManagerGetSecretValuePolicy
](#secrets-manager-get-secret-value-policy)
+ [
## AWSSecretsManagerRotationPolicy
](#secrets-manager-rotation-policy)
+ [
## CloudFormationDescribeStacksPolicy
](#cloud-formation-describe-stacks-policy)
+ [
## CloudWatchDashboardPolicy
](#cloudwatch-dashboard-policy)
+ [
## CloudWatchDescribeAlarmHistoryPolicy
](#cloudwatch-describe-alarm-history-policy)
+ [
## CloudWatchPutMetricPolicy
](#cloudwatch-put-metric-policy)
+ [
## CodePipelineLambdaExecutionPolicy
](#code-pipeline-lambda-execution-policy)
+ [
## CodePipelineReadOnlyPolicy
](#code-pipeline-readonly-policy)
+ [
## CodeCommitCrudPolicy
](#codecommit-crud-policy)
+ [
## CodeCommitReadPolicy
](#codecommit-read-policy)
+ [
## ComprehendBasicAccessPolicy
](#comprehend-basic-access-policy)
+ [
## CostExplorerReadOnlyPolicy
](#cost-explorer-readonly-policy)
+ [
## DynamoDBBackupFullAccessPolicy
](#ddb-back-full-policy)
+ [
## DynamoDBCrudPolicy
](#dynamo-db-crud-policy)
+ [
## DynamoDBReadPolicy
](#dynamo-db-read-policy)
+ [
## DynamoDBReconfigurePolicy
](#dynamo-db-reconfigure-policy)
+ [
## DynamoDBRestoreFromBackupPolicy
](#ddb-restore-from-backup-policy)
+ [
## DynamoDBStreamReadPolicy
](#dynamo-db-stream-read-policy)
+ [
## DynamoDBWritePolicy
](#dynamo-db-write-policy)
+ [
## EC2CopyImagePolicy
](#ec2-copy-image-policy)
+ [
## EC2DescribePolicy
](#ec2-describe-policy)
+ [
## EcsRunTaskPolicy
](#ecs-run-task-policy)
+ [
## EFSWriteAccessPolicy
](#efs-write-access-policy)
+ [
## EKSDescribePolicy
](#eks-describe-policy)
+ [
## ElasticMapReduceAddJobFlowStepsPolicy
](#elastic-map-reduce-add-job-flows-policy)
+ [
## ElasticMapReduceCancelStepsPolicy
](#elastic-map-reduce-cancel-steps-policy)
+ [
## ElasticMapReduceModifyInstanceFleetPolicy
](#elastic-map-reduce-modify-instance-fleet-policy)
+ [
## ElasticMapReduceModifyInstanceGroupsPolicy
](#elastic-map-reduce-modify-instance-groups-policy)
+ [
## ElasticMapReduceSetTerminationProtectionPolicy
](#elastic-map-reduce-set-termination-protection-policy)
+ [
## ElasticMapReduceTerminateJobFlowsPolicy
](#elastic-map-reduce-terminate-job-flows-policy)
+ [
## ElasticsearchHttpPostPolicy
](#elastic-search-http-post-policy)
+ [
## EventBridgePutEventsPolicy
](#eventbridge-put-events-policy)
+ [
## FilterLogEventsPolicy
](#filter-log-events-policy)
+ [
## FirehoseCrudPolicy
](#firehose-crud-policy)
+ [
## FirehoseWritePolicy
](#firehose-write-policy)
+ [
## KinesisCrudPolicy
](#kinesis-crud-policy)
+ [
## KinesisStreamReadPolicy
](#kinesis-stream-read-policy)
+ [
## KMSDecryptPolicy
](#kms-decrypt-policy)
+ [
## KMSEncryptPolicy
](#kms-encrypt-policy)
+ [
## LambdaInvokePolicy
](#lambda-invoke-policy)
+ [
## MobileAnalyticsWriteOnlyAccessPolicy
](#mobile-analytics-write-only-access-policy)
+ [
## OrganizationsListAccountsPolicy
](#organizations-list-accounts-policy)
+ [
## PinpointEndpointAccessPolicy
](#pinpoint-endpoint-access-policy)
+ [
## PollyFullAccessPolicy
](#polly-full-access-policy)
+ [
## RekognitionDetectOnlyPolicy
](#rekognition-detect-only-policy)
+ [
## RekognitionFacesManagementPolicy
](#rekognition-face-management-policy)
+ [
## RekognitionFacesPolicy
](#rekognition-faces-policy)
+ [
## RekognitionLabelsPolicy
](#rekognition-labels-policy)
+ [
## RekognitionNoDataAccessPolicy
](#rekognition-no-data-access-policy)
+ [
## RekognitionReadPolicy
](#rekognition-read-policy)
+ [
## RekognitionWriteOnlyAccessPolicy
](#rekognition-write-only-access-policy)
+ [
## Route53ChangeResourceRecordSetsPolicy
](#route53-change-resource-record-sets-policy)
+ [
## S3CrudPolicy
](#s3-crud-policy)
+ [
## S3FullAccessPolicy
](#s3-full-access-policy)
+ [
## S3ReadPolicy
](#s3-read-policy)
+ [
## S3WritePolicy
](#s3-write-policy)
+ [
## SageMakerCreateEndpointConfigPolicy
](#sagemaker-create-endpoint-config-policy)
+ [
## SageMakerCreateEndpointPolicy
](#sagemaker-create-endpoint-policy)
+ [
## ServerlessRepoReadWriteAccessPolicy
](#serverlessrepo-read-write-access-policy)
+ [
## SESBulkTemplatedCrudPolicy
](#ses-bulk-templated-crud-policy)
+ [
## SESBulkTemplatedCrudPolicy\$1v2
](#ses-bulk-templated-crud-policy-v2)
+ [
## SESCrudPolicy
](#ses-crud-policy)
+ [
## SESEmailTemplateCrudPolicy
](#ses-email-template-crud-policy)
+ [
## SESSendBouncePolicy
](#ses-send-bounce-policy)
+ [
## SNSCrudPolicy
](#sns-crud-policy)
+ [
## SNSPublishMessagePolicy
](#sqs-publish-message-policy)
+ [
## SQSPollerPolicy
](#sqs-poller-policy)
+ [
## SQSSendMessagePolicy
](#sqs-send-message-policy)
+ [
## SSMParameterReadPolicy
](#ssm-parameter-read-policy)
+ [
## SSMParameterWithSlashPrefixReadPolicy
](#ssm-parameter-slash-read-policy)
+ [
## StepFunctionsExecutionPolicy
](#stepfunctions-execution-policy)
+ [
## TextractDetectAnalyzePolicy
](#textract-detect-analyze-policy)
+ [
## TextractGetResultPolicy
](#textract-get-result-policy)
+ [
## TextractPolicy
](#textract-policy)
+ [
## VPCAccessPolicy
](#vpc-access-policy)
## AcmGetCertificatePolicy
Fornisce il permesso di leggere un certificato da. AWS Certificate Manager
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Autorizza a descrivere Amazon Machine Images (AMIs).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Fornisce le autorizzazioni per eseguire le query Athena.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:GetExecutionEngine",
"athena:GetExecutionEngines",
"athena:GetNamespace",
"athena:GetCatalogs",
"athena:GetNamespaces",
"athena:GetTables",
"athena:GetTable"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:DeleteNamedQuery",
"athena:GetNamedQuery",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResultsStream",
"athena:ListNamedQueries",
"athena:CreateNamedQuery",
"athena:GetQueryExecution",
"athena:BatchGetNamedQuery",
"athena:BatchGetQueryExecution",
"athena:GetWorkGroup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
{
"workgroupName": {
"Ref": "WorkGroupName"
}
}
]
}
}
]
```
## AWSSecretsManagerGetSecretValuePolicy
Autorizza a ottenere il valore segreto per il segreto specificato. Gestione dei segreti AWS
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Dà il permesso di far ruotare un segreto. Gestione dei segreti AWS
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
},
"Condition": {
"StringEquals": {
"secretsmanager:resource/AllowRotationLambdaArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
}
]
```
## CloudFormationDescribeStacksPolicy
Dà il permesso di descrivere le CloudFormation pile.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Fornisce le autorizzazioni per inserire le metriche in modo che funzionino nei dashboard. CloudWatch
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Autorizza a descrivere la cronologia degli CloudWatch allarmi di Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Autorizza a inviare metriche a. CloudWatch
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Fornisce l'autorizzazione a una funzione Lambda richiamata da AWS CodePipeline per segnalare lo stato del lavoro.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Fornisce il permesso di lettura per ottenere dettagli su una CodePipeline pipeline.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Fornisce le autorizzazioni per creare, leggere, aggiornare ed eliminare oggetti all'interno di un CodeCommit repository specifico.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:CreateBranch",
"codecommit:DeleteBranch",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:MergeBranchesByFastForward",
"codecommit:MergeBranchesBySquash",
"codecommit:MergeBranchesByThreeWay",
"codecommit:UpdateDefaultBranch",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:CreatePullRequest",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:MergePullRequestByFastForward",
"codecommit:MergePullRequestBySquash",
"codecommit:MergePullRequestByThreeWay",
"codecommit:PostCommentForPullRequest",
"codecommit:UpdatePullRequestDescription",
"codecommit:UpdatePullRequestStatus",
"codecommit:UpdatePullRequestTitle",
"codecommit:DeleteFile",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:PutFile",
"codecommit:DeleteCommentContent",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:PostCommentForComparedCommit",
"codecommit:PostCommentReply",
"codecommit:UpdateComment",
"codecommit:BatchGetCommits",
"codecommit:CreateCommit",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:UpdateRepositoryDescription",
"codecommit:ListTagsForResource",
"codecommit:TagResource",
"codecommit:UntagResource",
"codecommit:GetRepositoryTriggers",
"codecommit:PutRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## CodeCommitReadPolicy
Fornisce le autorizzazioni per leggere oggetti all'interno di un CodeCommit repository specifico.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:BatchGetCommits",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:ListTagsForResource",
"codecommit:GetRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## ComprehendBasicAccessPolicy
Autorizza il rilevamento di entità, frasi chiave, lingue e sentimenti.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Fornisce l'autorizzazione di sola lettura alla modalità di sola lettura (Cost AWS Cost Explorer Explorer) APIs per la cronologia di fatturazione.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
Fornisce l'autorizzazione di lettura e scrittura ai backup su richiesta di DynamoDB per una tabella.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:DescribeContinuousBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteBackup",
"dynamodb:DescribeBackup",
"dynamodb:ListBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBCrudPolicy
Fornisce autorizzazioni di creazione, lettura, aggiornamento ed eliminazione per una tabella Amazon DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:DeleteItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReadPolicy
Fornisce l'autorizzazione di sola lettura a una tabella DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReconfigurePolicy
Fornisce il permesso di riconfigurare una tabella DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
Autorizza il ripristino di una tabella DynamoDB dal backup.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:RestoreTableFromBackup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBStreamReadPolicy
Autorizza a descrivere e leggere i flussi e i record di DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
{
"tableName": {
"Ref": "TableName"
},
"streamName": {
"Ref": "StreamName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:ListStreams"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBWritePolicy
Fornisce l'autorizzazione di sola scrittura a una tabella DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## EC2CopyImagePolicy
Autorizza a copiare EC2 le immagini di Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Autorizza a descrivere le istanze di Amazon Elastic Compute Cloud (Amazon EC2).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Dà il permesso di iniziare una nuova attività per la definizione di un'attività.
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
Autorizza il montaggio di un file system Amazon EFS con accesso in scrittura.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
{
"FileSystem": {
"Ref": "FileSystem"
}
}
]
},
"Condition": {
"StringEquals": {
"elasticfilesystem:AccessPointArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
{
"AccessPoint": {
"Ref": "AccessPoint"
}
}
]
}
}
}
}
]
```
## EKSDescribePolicy
Autorizza a descrivere o elencare i cluster Amazon Elastic Kubernetes Service (Amazon EKS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Autorizza ad aggiungere nuovi passaggi a un cluster in esecuzione.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Autorizza l'annullamento di uno o più passaggi in sospeso in un cluster in esecuzione.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Autorizza a elencare i dettagli e modificare le capacità, ad esempio le flotte all'interno di un cluster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceGroupsPolicy
Autorizza a elencare i dettagli e modificare le impostazioni per i gruppi di istanze all'interno di un cluster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceSetTerminationProtectionPolicy
Fornisce il permesso di impostare la protezione dalla terminazione per un cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Autorizza la chiusura di un cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Fornisce le autorizzazioni POST e PUT ad Amazon OpenSearch Service.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
{
"domainName": {
"Ref": "DomainName"
}
}
]
}
}
]
```
## EventBridgePutEventsPolicy
Fornisce le autorizzazioni per inviare eventi ad Amazon EventBridge.
```
"Statement": [
{
"Effect": "Allow",
"Action": "events:PutEvents",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
{
"eventBusName": {
"Ref": "EventBusName"
}
}
]
}
}
]
```
## FilterLogEventsPolicy
Autorizza a filtrare gli eventi di CloudWatch Logs da un gruppo di log specificato.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:FilterLogEvents"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
{
"logGroupName": {
"Ref": "LogGroupName"
}
}
]
}
}
]
```
## FirehoseCrudPolicy
Autorizza a creare, scrivere, aggiornare ed eliminare un flusso di distribuzione Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:CreateDeliveryStream",
"firehose:DeleteDeliveryStream",
"firehose:DescribeDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch",
"firehose:UpdateDestination"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## FirehoseWritePolicy
Autorizza la scrittura su un flusso di distribuzione Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## KinesisCrudPolicy
Autorizza a creare, pubblicare ed eliminare uno stream Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:AddTagsToStream",
"kinesis:CreateStream",
"kinesis:DecreaseStreamRetentionPeriod",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetShardIterator",
"kinesis:IncreaseStreamRetentionPeriod",
"kinesis:ListTagsForStream",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:PutRecords",
"kinesis:SplitShard",
"kinesis:RemoveTagsFromStream"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KinesisStreamReadPolicy
Autorizza a elencare e leggere uno stream Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:ListStreams",
"kinesis:DescribeLimits"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
}
},
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetRecords",
"kinesis:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KMSDecryptPolicy
Dà il permesso di decrittografare con una AWS Key Management Service chiave ().AWS KMS Nota che `keyId` deve essere un ID di AWS KMS chiave e non un alias di chiave.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Autorizza la crittografia con una AWS KMS chiave. Nota che keyID deve essere un ID AWS KMS chiave e non un alias di chiave.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Fornisce il permesso di richiamare una AWS Lambda funzione, un alias o una versione.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Fornisce l'autorizzazione di sola scrittura per inserire i dati degli eventi per tutte le risorse dell'applicazione.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Fornisce l'autorizzazione di sola lettura per elencare i nomi degli account secondari e. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Autorizza a ottenere e aggiornare gli endpoint per un'applicazione Amazon Pinpoint.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobiletargeting:GetEndpoint",
"mobiletargeting:UpdateEndpoint",
"mobiletargeting:UpdateEndpointsBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
{
"pinpointApplicationId": {
"Ref": "PinpointApplicationId"
}
}
]
}
}
]
```
## PollyFullAccessPolicy
Fornisce l'autorizzazione di accesso completo alle risorse lessicali di Amazon Polly.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
{
"lexiconName": {
"Ref": "LexiconName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:ListLexicons",
"polly:PutLexicon",
"polly:SynthesizeSpeech"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
}
]
}
]
```
## RekognitionDetectOnlyPolicy
Autorizza a rilevare volti, etichette e testo.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Autorizza ad aggiungere, eliminare e cercare volti in una raccolta Amazon Rekognition.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:IndexFaces",
"rekognition:DeleteFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage",
"rekognition:ListFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionFacesPolicy
Autorizza il confronto e il rilevamento di volti ed etichette.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Autorizza il rilevamento degli oggetti e delle etichette di moderazione.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Autorizza a confrontare e rilevare volti ed etichette.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionReadPolicy
Autorizza a elencare e cercare volti.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:ListCollections",
"rekognition:ListFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionWriteOnlyAccessPolicy
Autorizza a creare volti da collezione e da indicizzare.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CreateCollection",
"rekognition:IndexFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## Route53ChangeResourceRecordSetsPolicy
Autorizza a modificare i set di record di risorse in Route 53.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Fornisce l'autorizzazione di creazione, lettura, aggiornamento ed eliminazione per agire sugli oggetti in un bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration",
"s3:DeleteObject"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3FullAccessPolicy
Fornisce l'autorizzazione di accesso completa per agire sugli oggetti in un bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:DeleteObject",
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3ReadPolicy
Fornisce l'autorizzazione di sola lettura per leggere oggetti in un bucket Amazon Simple Storage Service (Amazon S3).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:GetLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3WritePolicy
Fornisce il permesso di scrittura per scrivere oggetti in un bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## SageMakerCreateEndpointConfigPolicy
Fornisce il permesso di creare una configurazione degli endpoint in SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Dà il permesso di creare un endpoint in SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpoint"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
{
"endpointName": {
"Ref": "EndpointName"
}
}
]
},
"Effect": "Allow"
}
]
```
## ServerlessRepoReadWriteAccessPolicy
Autorizza a creare ed elencare applicazioni nel servizio AWS Serverless Application Repository (AWS SAM).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"serverlessrepo:CreateApplication",
"serverlessrepo:CreateApplicationVersion",
"serverlessrepo:GetApplication",
"serverlessrepo:ListApplications",
"serverlessrepo:ListApplicationVersions"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
}
]
}
]
```
## SESBulkTemplatedCrudPolicy
Autorizza a inviare e-mail Amazon SES, e-mail basate su modelli e e-mail collettive basate su modelli e a verificare l'identità.
**Nota**
L'`ses:SendTemplatedEmail`azione richiede un modello ARN. Usare invece `SESBulkTemplatedCrudPolicy_v2`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESBulkTemplatedCrudPolicy\$1v2
Autorizza a inviare e-mail Amazon SES, e-mail basate su modelli e e-mail collettive basate su modelli e a verificare l'identità.
```
"Statement": [
{
"Action": [
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail"
],
"Effect": "Allow",
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
{
"templateName": {
"Ref": "TemplateName"
}
}
]
}
]
},
{
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:VerifyEmailIdentity"
],
"Effect": "Allow",
"Resource": "*"
}
]
```
## SESCrudPolicy
Autorizza l'invio di e-mail e la verifica dell'identità.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESEmailTemplateCrudPolicy
Autorizza a creare, ottenere, elencare, aggiornare ed eliminare modelli di e-mail Amazon SES.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
Fornisce SendBounce l'autorizzazione a un'identità Amazon Simple Email Service (Amazon SES).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:SendBounce"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SNSCrudPolicy
Autorizza a creare, pubblicare e sottoscrivere argomenti di Amazon SNS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:ListSubscriptionsByTopic",
"sns:CreateTopic",
"sns:SetTopicAttributes",
"sns:Subscribe",
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SNSPublishMessagePolicy
Autorizza a pubblicare un messaggio su un argomento di Amazon Simple Notification Service (Amazon SNS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SQSPollerPolicy
Autorizza il polling di una coda Amazon Simple Queue Service (Amazon SQS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:ChangeMessageVisibilityBatch",
"sqs:DeleteMessage",
"sqs:DeleteMessageBatch",
"sqs:GetQueueAttributes",
"sqs:ReceiveMessage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SQSSendMessagePolicy
Autorizza l'invio di messaggi a una coda Amazon SQS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Fornisce l'autorizzazione ad accedere a un parametro da un archivio di parametri Amazon EC2 Systems Manager (SSM) per caricare i segreti in questo account. Da utilizzare quando il nome del parametro non ha il prefisso slash.
**Nota**
Se non si utilizza la chiave predefinita, sarà necessaria anche la `KMSDecryptPolicy` politica.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## SSMParameterWithSlashPrefixReadPolicy
Fornisce l'autorizzazione ad accedere a un parametro da un archivio di parametri Amazon EC2 Systems Manager (SSM) per caricare i segreti in questo account. Da utilizzare quando il nome del parametro ha un prefisso slash.
**Nota**
Se non si utilizza la chiave predefinita, sarà necessaria anche la `KMSDecryptPolicy` politica.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## StepFunctionsExecutionPolicy
Fornisce il permesso di avviare l'esecuzione di una macchina a stati Step Functions.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
{
"stateMachineName": {
"Ref": "StateMachineName"
}
}
]
}
}
]
```
## TextractDetectAnalyzePolicy
Fornisce l'accesso per rilevare e analizzare documenti con Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Fornisce l'accesso per ottenere documenti rilevati e analizzati da Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Fornisce accesso completo ad Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Fornisce l'accesso per creare, eliminare, descrivere e scollegare interfacce di rete elastiche.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Gestione delle AWS SAM autorizzazioni con meccanismi CloudFormation
Per controllare l'accesso alle AWS risorse, il AWS Serverless Application Model (AWS SAM) può utilizzare gli stessi CloudFormation meccanismi di. Per ulteriori informazioni, consulta [Controllo dell’accesso con AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) nella *Guida per l’utente di AWS CloudFormation *.
Esistono tre opzioni principali per concedere all'utente l'autorizzazione a gestire applicazioni serverless. Ciascuna opzione offre agli utenti diversi livelli di controllo degli accessi.
+ Concedi le autorizzazioni di amministratore.
+ Allega le politiche AWS gestite necessarie.
+ Concedi autorizzazioni specifiche AWS Identity and Access Management (IAM).
A seconda dell'opzione scelta, gli utenti possono gestire solo applicazioni serverless contenenti AWS risorse a cui hanno l'autorizzazione di accesso.
Le sezioni seguenti descrivono ciascuna opzione in modo più dettagliato.
## Concedi le autorizzazioni di amministratore
Se concedi le autorizzazioni di amministratore a un utente, quest'ultimo può gestire applicazioni serverless che contengono qualsiasi combinazione di risorse. AWS Questa è l'opzione più semplice, ma concede anche agli utenti il set di autorizzazioni più ampio, che quindi consente loro di eseguire azioni con il massimo impatto.
*Per ulteriori informazioni sulla concessione delle autorizzazioni di amministratore a un utente, consulta [Creazione del primo utente e gruppo di amministratori IAM nella Guida per l'utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) IAM.*
## Allega le politiche gestite necessarie AWS
È possibile concedere agli utenti un sottoinsieme di autorizzazioni utilizzando [policy AWS gestite](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies), anziché concedere autorizzazioni amministrative complete. Se utilizzi questa opzione, assicurati che il set di policy AWS gestite copra tutte le azioni e le risorse necessarie per le applicazioni serverless gestite dagli utenti.
Ad esempio, le seguenti politiche AWS gestite sono sufficienti per [distribuire l'applicazione Hello World di esempio](serverless-getting-started-hello-world.md):
+ AWSCloudFormationFullAccess
+ IAMFullAccesso
+ AWSLambda\$1FullAccess
+ APIGatewayAmministratore Amazon
+ Amazon S3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Per informazioni sull'associazione delle policy a un utente IAM, consulta [Modifica delle autorizzazioni per un utente IAM nella Guida per l'utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) *IAM*.
## Concedi autorizzazioni IAM specifiche
[Per il livello più granulare di controllo degli accessi, puoi concedere autorizzazioni IAM specifiche agli utenti utilizzando le istruzioni sulle policy.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html) Se utilizzi questa opzione, assicurati che l'informativa sulla politica includa tutte le azioni e le risorse necessarie per le applicazioni serverless gestite dagli utenti.
La migliore pratica con questa opzione consiste nel negare agli utenti l'autorizzazione a creare ruoli, inclusi i ruoli di esecuzione Lambda, in modo che non possano concedersi autorizzazioni avanzate. Pertanto, l'amministratore deve prima creare un [ruolo di esecuzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) che verrà specificato nelle applicazioni serverless gestite dagli utenti. Per informazioni sulla creazione di ruoli di esecuzione Lambda, consulta [Creazione di un ruolo di esecuzione nella console IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Per l'[applicazione Hello World di esempio **AWSLambdaBasicExecutionRole**](serverless-getting-started-hello-world.md)è sufficiente eseguire l'applicazione. Dopo aver creato un ruolo di esecuzione Lambda, modifica il file AWS SAM modello dell'applicazione Hello World di esempio per aggiungere la seguente proprietà alla `AWS::Serverless::Function` risorsa:
```
Role: lambda-execution-role-arn
```
Con l'applicazione Hello World modificata, la seguente dichiarazione politica concede agli utenti autorizzazioni sufficienti per distribuire, aggiornare ed eliminare l'applicazione:
**Nota**
[L'informativa di esempio contenuta in questa sezione concede autorizzazioni sufficienti per distribuire, aggiornare ed eliminare l'applicazione Hello World di esempio.](serverless-getting-started-hello-world.md) Se aggiungi altri tipi di risorse all'applicazione, devi aggiornare l'informativa sulla politica per includere quanto segue:
Autorizzazione per l'applicazione a richiamare le azioni del servizio.
Il responsabile del servizio, se necessario per le azioni del servizio.
Ad esempio, se si aggiunge un flusso di lavoro Step Functions, potrebbe essere necessario aggiungere le autorizzazioni per le azioni elencate [qui](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions) e il responsabile del `states.amazonaws.com` servizio.
Per ulteriori informazioni sulle policy IAM, consulta [Managing IAM policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) nella *IAM User Guide*.
# Controlla l'accesso alle API con il tuo AWS SAM modello
Il controllo dell'accesso al tuo API Gateway APIs aiuta a garantire che l'applicazione serverless sia sicura e accessibile solo tramite l'autorizzazione abilitata. Puoi abilitare l'autorizzazione nel tuo AWS SAM modello per controllare chi può accedere al tuo API Gateway APIs.
AWS SAM supporta diversi meccanismi per controllare l'accesso al tuo API Gateway APIs. L'insieme di meccanismi supportati varia a seconda dei tipi `AWS::Serverless::HttpApi` di `AWS::Serverless::Api` risorse.
La tabella seguente riassume i meccanismi supportati da ciascun tipo di risorsa.
| Meccanismi per il controllo dell'accesso | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Autorizzatori Lambda | ✓ | ✓ |
| Autorizzazioni IAM | | ✓ |
| Pool di utenti Amazon Cognito | ✓ \$1 | ✓ |
| Chiavi API | | ✓ |
| Policy delle risorse | | ✓ |
| OAuth Autorizzatori 2.0/JWT | ✓ | |
\$1 Puoi usare Amazon Cognito come emittente di JSON Web Token (JWT) con il tipo di risorsa. `AWS::Serverless::HttpApi`
+ **Autorizzatori Lambda: un autorizzatore** Lambda (precedentemente noto come autorizzatore personalizzato*)* è una funzione Lambda fornita per controllare l'accesso all'API. Quando viene chiamata l'API, questa funzione Lambda viene richiamata con un contesto di richiesta o un token di autorizzazione fornito dall'applicazione client. La funzione Lambda risponde se il chiamante è autorizzato a eseguire l'operazione richiesta.
Entrambi i tipi `AWS::Serverless::HttpApi` di `AWS::Serverless::Api` risorse supportano gli autorizzatori Lambda.
Per ulteriori informazioni sugli autorizzatori Lambda con`AWS::Serverless::HttpApi`, consulta [Working with AWS Lambda authorizers for HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) nella APIs *API* Gateway Developer Guide. *Per ulteriori informazioni sugli autorizzatori Lambda con`AWS::Serverless::Api`, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*
Per esempi di autorizzatori Lambda per entrambi i tipi di risorse, vedere. [Esempi di autorizzazioni Lambda per AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ **Autorizzazioni IAM**: puoi controllare chi può richiamare la tua API utilizzando le autorizzazioni [AWS Identity and Access Management (](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html)IAM). Gli utenti che chiamano la tua API devono essere autenticati con credenziali IAM. Le chiamate alla tua API hanno esito positivo solo se all'utente IAM è associata una policy IAM che rappresenta il chiamante dell'API, un gruppo IAM che contiene l'utente o un ruolo IAM assunto dall'utente.
Solo il tipo di `AWS::Serverless::Api` risorsa supporta le autorizzazioni IAM.
Per ulteriori informazioni, consulta [Controllare l'accesso a un'API con autorizzazioni IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) nella *Guida per sviluppatori di API Gateway*. Per vedere un esempio, consulta [Esempio di autorizzazione IAM per AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ Pool di utenti **Amazon Cognito: i pool di utenti** di Amazon Cognito sono directory di utenti in Amazon Cognito. Un client della tua API deve prima accedere a un utente al pool di utenti e ottenere un'identità o un token di accesso per l'utente. Quindi il client chiama l'API con uno dei token restituiti. La chiamata API ha esito positivo solo se il token richiesto è valido.
Il tipo di `AWS::Serverless::Api` risorsa supporta i pool di utenti di Amazon Cognito. Il tipo di `AWS::Serverless::HttpApi` risorsa supporta l'uso di Amazon Cognito come emittente JWT.
Per ulteriori informazioni, consulta la sezione [Control access to a REST API using Amazon Cognito user pools as authorizer (Controllo degli accessi a un'API REST utilizzando pool di utenti di Amazon Cognito come autorizzazione)](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) nella *Guida per sviluppatori di API Gateway*. Per vedere un esempio, consulta [Esempio di pool di utenti Amazon Cognito per AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **Chiavi API: le** chiavi API sono valori di stringhe alfanumeriche che distribuisci ai clienti sviluppatori di applicazioni per concedere l'accesso alla tua API.
Solo il tipo di `AWS::Serverless::Api` risorsa supporta le chiavi API.
Per ulteriori informazioni sulle chiavi API, consulta [Creazione e utilizzo di piani di utilizzo con chiavi API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) nella *Guida per sviluppatori di API Gateway*. Per un esempio di chiavi API, consulta[Esempio di chiave API per AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Politiche delle** risorse: le politiche delle risorse sono documenti di policy JSON che è possibile allegare a un'API API Gateway. Utilizza le policy relative alle risorse per controllare se un principale specificato (in genere un utente o un ruolo IAM) può richiamare l'API.
Solo il tipo di `AWS::Serverless::Api` risorsa supporta le policy delle risorse come meccanismo per controllare l'accesso all'API Gateway APIs.
Per ulteriori informazioni sulle politiche delle risorse, consulta [Controllare l'accesso a un'API con le politiche delle risorse di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) nella *Guida per sviluppatori di API Gateway*. Per un esempio di politiche relative alle risorse, consulta[Esempio di policy in materia di risorse per AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth Autorizzatori 2.0/JWT**[: puoi utilizzare JWTs come parte dei framework OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e OAuth 2.0 per controllare l'accesso al tuo.](https://oauth.net/2/) APIs API Gateway convalida JWTs le richieste API inviate dai client e consente o rifiuta le richieste in base alla convalida del token e, facoltativamente, agli ambiti nel token.
Solo il tipo di `AWS::Serverless::HttpApi` risorsa supporta gli autorizzatori 2.0/JWT. OAuth
Per ulteriori informazioni, consulta [Controllare l'accesso a HTTP APIs con gli autorizzatori JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) nella *API Gateway Developer Guide*. Per vedere un esempio, consulta [OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).
## Scelta di un meccanismo per controllare l'accesso
Il meccanismo che scegli di utilizzare per controllare l'accesso al tuo API Gateway APIs dipende da alcuni fattori. Ad esempio, se hai un progetto greenfield senza autorizzazione o configurazione del controllo degli accessi, i pool di utenti di Amazon Cognito potrebbero essere l'opzione migliore. Questo perché quando configuri i pool di utenti, configuri automaticamente anche l'autenticazione e il controllo degli accessi.
Tuttavia, se l'applicazione ha già configurato l'autenticazione, l'utilizzo degli autorizzatori Lambda potrebbe essere l'opzione migliore. Questo perché puoi chiamare il servizio di autenticazione esistente e restituire un documento di policy basato sulla risposta. Inoltre, se la tua applicazione richiede un'autenticazione personalizzata o una logica di controllo degli accessi che i pool di utenti non supportano, gli autorizzatori Lambda potrebbero essere l'opzione migliore.
Dopo aver scelto il meccanismo da utilizzare, consulta la sezione corrispondente [Esempi](#serverless-controlling-access-to-apis-examples) per scoprire come configurare l'applicazione AWS SAM per utilizzare quel meccanismo.
## Personalizzazione delle risposte agli errori
È possibile utilizzarlo AWS SAM per personalizzare il contenuto di alcune risposte di errore di API Gateway. Solo il tipo di `AWS::Serverless::Api` risorsa supporta risposte API Gateway personalizzate.
Per ulteriori informazioni sulle risposte di API Gateway, consulta le [risposte del gateway in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) nella *API Gateway Developer Guide*. Per un esempio di risposte personalizzate, consulta[Esempio di risposta personalizzata per AWS SAM](serverless-controlling-access-to-apis-customize-response.md).
## Esempi
+ [Esempi di autorizzazioni Lambda per AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Esempio di autorizzazione IAM per AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Esempio di pool di utenti Amazon Cognito per AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Esempio di chiave API per AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Esempio di policy in materia di risorse per AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Esempio di risposta personalizzata per AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# Esempi di autorizzazioni Lambda per AWS SAM
Il tipo di `AWS::Serverless::Api` risorsa supporta due tipi di autorizzatori Lambda: autorizzatori e `TOKEN` autorizzatori. `REQUEST` Il tipo di `AWS::Serverless::HttpApi` risorsa supporta solo gli autorizzatori. `REQUEST` Di seguito sono riportati alcuni esempi di ogni tipo.
## Esempio di `TOKEN` autorizzazione Lambda () AWS::Serverless::Api
Puoi controllare l'accesso al tuo APIs definendo un `TOKEN` autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore Lambda: `TOKEN`
**Nota**
Nell'esempio seguente, il SAM `FunctionRole` viene generato implicitamente.
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
*Per ulteriori informazioni sugli autorizzatori Lambda, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*
## Esempio di `REQUEST` autorizzazione Lambda () AWS::Serverless::Api
Puoi controllare l'accesso al tuo APIs definendo un `REQUEST` autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore Lambda: `REQUEST`
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
*Per ulteriori informazioni sugli autorizzatori Lambda, consulta Use API [Gateway Lambda authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) API Gateway Developer Guide.*
## Esempio di autorizzazione Lambda () AWS::Serverless::HttpApi
Puoi controllare l'accesso al tuo HTTP APIs definendo un autorizzatore Lambda all'interno del tuo modello. AWS SAM A tale scopo, si utilizza il tipo di [HttpApiAuth](sam-property-httpapi-httpapiauth.md) dati.
Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore Lambda:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# Esempio di autorizzazione IAM per AWS SAM
Puoi controllare l'accesso al tuo APIs definendo le autorizzazioni IAM all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un AWS SAM modello di esempio che utilizza per le autorizzazioni IAM:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
Per ulteriori informazioni sulle autorizzazioni IAM, consulta [Control access for invoking an API nella API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) *Gateway Developer Guide*.
# Esempio di pool di utenti Amazon Cognito per AWS SAM
Puoi controllare l'accesso ai tuoi utenti APIs definendo i pool di utenti di Amazon Cognito all'interno del AWS SAM modello. Per fare ciò, usi il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un esempio AWS SAM di sezione modello per un pool di utenti:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Per ulteriori informazioni sui pool di utenti di Amazon Cognito, consulta [Controllare l'accesso a un'API REST utilizzando i pool di utenti di Amazon Cognito come](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) autorizzatore nella Guida per sviluppatori di API *Gateway*.
# Esempio di chiave API per AWS SAM
Puoi controllare l'accesso al tuo APIs richiedendo le chiavi API all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un esempio di sezione AWS SAM modello per le chiavi API:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
Per ulteriori informazioni sulle chiavi API, consulta [Creazione e utilizzo di piani di utilizzo con chiavi API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) nella *Guida per sviluppatori di API Gateway*.
# Esempio di policy in materia di risorse per AWS SAM
Puoi controllare l'accesso ai tuoi APIs allegando una politica delle risorse all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di [ApiAuth](sam-property-api-apiauth.md) dati.
Di seguito è riportato un AWS SAM modello di esempio per un'API privata. Un'API privata deve disporre di una politica delle risorse da distribuire.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
Per ulteriori informazioni sulle politiche delle risorse, consulta [Controllare l'accesso a un'API con le politiche delle risorse di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) nella *Guida per sviluppatori di API Gateway*. Per ulteriori informazioni sulla privacy APIs, consulta la sezione [Creazione di un'API privata in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) nella *API Gateway Developer Guide*.
# OAuth Esempio di autorizzazione 2.0/JWT per AWS SAM
[Puoi controllare l'accesso al tuo APIs utilizzo JWTs come parte dei framework [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e 2.0. OAuth ](https://oauth.net/2/) A tale scopo, si utilizza il tipo di dati. [HttpApiAuth](sam-property-httpapi-httpapiauth.md)
Di seguito è riportato un esempio di sezione AWS SAM modello per un autorizzatore OAuth 2.0/JWT:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
*Per ulteriori informazioni sugli autorizzatori OAuth 2.0/JWT, consulta [Controlling access to HTTP APIs with JWT authorizers nella](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) API Gateway Developer Guide.*
# Esempio di risposta personalizzata per AWS SAM
Puoi personalizzare alcune risposte di errore di API Gateway definendo le intestazioni di risposta all'interno del tuo AWS SAM modello. A tale scopo, si utilizza il tipo di dati [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).
Di seguito è riportato un AWS SAM modello di esempio che crea una risposta personalizzata per l'`DEFAULT_5XX`errore.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
Per ulteriori informazioni sulle risposte di API Gateway, consulta le [risposte del gateway in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) nella *API Gateway Developer Guide*.
# Aumenta l'efficienza utilizzando i livelli Lambda con AWS SAM
Utilizzando AWS SAM, è possibile includere livelli nelle applicazioni serverless. AWS Lambda i livelli consentono di estrarre il codice da una funzione Lambda in un livello Lambda che può quindi essere utilizzato in diverse funzioni Lambda. In questo modo è possibile ridurre le dimensioni dei pacchetti di distribuzione, separare la logica delle funzioni principali dalle dipendenze e condividere le dipendenze tra più funzioni. Per ulteriori informazioni sui layer, consulta i [layer Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) nella *AWS Lambda Developer* Guide.
Questo argomento fornisce informazioni su quanto segue:
+ Inclusione di livelli nell'applicazione
+ In che modo i livelli vengono memorizzati nella cache locale
Per informazioni sulla creazione di livelli personalizzati, consulta[Creazione di livelli Lambda in AWS SAM](building-layers.md).
## Inclusione di livelli nell'applicazione
Per includere livelli nell'applicazione, utilizzate la `Layers` proprietà del tipo di [AWS::Serverless::Function](sam-resource-function.md) risorsa.
Di seguito è riportato un AWS SAM modello di esempio con una funzione Lambda che include un livello:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## Come i livelli vengono memorizzati nella cache locale
Quando si richiama la funzione utilizzando uno dei `sam local` comandi, il pacchetto layers della funzione viene scaricato e memorizzato nella cache sull'host locale.
La tabella seguente mostra le posizioni delle directory di cache predefinite per diversi sistemi operativi.
****
| Sistema operativo | Location (Ubicazione) |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
Dopo che il pacchetto è stato memorizzato nella cache, AWS SAMCLI sovrappone i livelli su un'immagine Docker utilizzata per richiamare la funzione. AWS SAMCLIGenera i nomi delle immagini che crea, oltre a LayerVersions quelle conservate nella cache. Puoi trovare maggiori dettagli sullo schema nelle seguenti sezioni.
Per ispezionare i livelli sovrapposti, esegui il seguente comando per avviare una sessione bash nell'immagine che vuoi ispezionare:
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**Schema dei nomi della Layer Caching Directory**
LayerVersionArn Dato un valore definito nel modello, AWS SAMCLI estrae la versione LayerName and dall'ARN. Crea una directory in cui inserire il contenuto del livello in named. `LayerName-Version-`
Esempio:
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Schema di tag Docker Images**
Per calcolare l'hash univoco dei livelli, combina tutti i nomi univoci dei livelli con un delimitatore «-», prendi l' SHA256 hash e poi prendi i primi 10 caratteri.
Esempio:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
I nomi univoci vengono calcolati nello stesso modo dello schema dei nomi di Layer Caching Directory:
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
Per calcolare l'hash univoco dei livelli, combina tutti i nomi univoci dei livelli con un delimitatore '-', prendi l'hash sha256 e poi prendi i primi 25 caratteri:
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
Quindi combina questo valore con il runtime e l'architettura della funzione, con un delimitatore di '-':
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# Riutilizza codice e risorse utilizzando applicazioni annidate in AWS SAM
Un'applicazione serverless può includere una o più applicazioni **annidate**. Un'applicazione nidificata fa parte di un'applicazione più ampia e può essere impacchettata e distribuita come elemento autonomo o come componente di un'applicazione più grande. Le applicazioni annidate consentono di trasformare il codice utilizzato di frequente in un'applicazione propria, che può quindi essere riutilizzata su un'applicazione serverless più grande o su più applicazioni serverless.
Man mano che le architetture serverless crescono, in genere emergono modelli comuni in cui gli stessi componenti sono definiti in più modelli di applicazione. Le applicazioni annidate consentono di riutilizzare codice, funzionalità, risorse e configurazioni comuni in AWS SAM modelli separati, consentendovi di gestire solo il codice proveniente da un'unica fonte. Ciò riduce il codice e le configurazioni duplicati. Inoltre, questo approccio modulare semplifica lo sviluppo, migliora l'organizzazione del codice e facilita la coerenza tra le applicazioni serverless. Con le applicazioni annidate, puoi concentrarti maggiormente sulla logica di business che è unica per la tua applicazione.
Per definire un'applicazione nidificata nella tua applicazione serverless, utilizza il [AWS::Serverless::Application](sam-resource-application.md) tipo di risorsa.
È possibile definire applicazioni nidificate dalle seguenti due fonti:
+ Un'**AWS Serverless Application Repository applicazione**: è possibile definire applicazioni nidificate utilizzando le applicazioni disponibili per il proprio account in. AWS Serverless Application Repository Queste possono essere applicazioni *private* nel tuo account, applicazioni *condivise privatamente* con il tuo account o applicazioni *condivise pubblicamente* in. AWS Serverless Application Repository*Per ulteriori informazioni sui diversi livelli di autorizzazioni di distribuzione, consulta [Autorizzazioni di distribuzione delle applicazioni](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) e [applicazioni di pubblicazione](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) nella Guida per gli AWS Serverless Application Repository sviluppatori.*
+ Un'**applicazione locale**: è possibile definire applicazioni annidate utilizzando applicazioni archiviate nel file system locale.
Consultate le sezioni seguenti per i dettagli su come AWS SAM definire entrambi questi tipi di applicazioni annidate nell'applicazione serverless.
**Nota**
Il numero massimo di applicazioni che possono essere annidate in un'applicazione serverless è 200.
Il numero massimo di parametri che un'applicazione annidata può avere è 60.
## Definizione di un'applicazione nidificata da AWS Serverless Application Repository
È possibile definire applicazioni nidificate utilizzando applicazioni disponibili in. AWS Serverless Application RepositoryÈ inoltre possibile archiviare e distribuire applicazioni che contengono applicazioni nidificate utilizzando. AWS Serverless Application Repository Per esaminare i dettagli di un'applicazione annidata in AWS Serverless Application Repository, puoi utilizzare l' AWS SDK, la o la console AWS CLI Lambda.
Per definire un'applicazione ospitata nel AWS SAM modello dell'applicazione serverless, utilizza il pulsante **Copia come risorsa SAM** nella pagina dei dettagli di ogni applicazione. AWS Serverless Application Repository AWS Serverless Application Repository A tale scopo, seguire queste fasi:
1. Assicurati di aver effettuato l'accesso a. Console di gestione AWS
1. Trova l'applicazione in cui desideri annidare AWS Serverless Application Repository utilizzando i passaggi indicati nella sezione [Navigazione, ricerca e distribuzione delle applicazioni](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ) della *Guida per gli AWS Serverless Application Repository sviluppatori*.
1. Scegli il pulsante **Copia come risorsa SAM**. La sezione dei modelli SAM per l'applicazione che stai visualizzando è ora negli appunti.
1. Incolla la sezione del modello SAM nella `Resources:` sezione del file modello SAM per l'applicazione che desideri annidare in questa applicazione.
Di seguito è riportato un esempio di sezione modello SAM per un'applicazione nidificata ospitata in: AWS Serverless Application Repository
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Se non sono presenti impostazioni dei parametri obbligatorie, è possibile omettere la `Parameters:` sezione del modello.
**Importante**
Le applicazioni che contengono applicazioni nidificate ospitate in AWS Serverless Application Repository ereditano le restrizioni di condivisione delle applicazioni nidificate.
Ad esempio, supponiamo che un'applicazione sia condivisa pubblicamente, ma contenga un'applicazione nidificata condivisa privatamente solo con l'account che ha creato l'applicazione principale. AWS In questo caso, se il tuo AWS account non dispone dell'autorizzazione per distribuire l'applicazione nidificata, non puoi distribuire l'applicazione principale. *Per ulteriori informazioni sulle autorizzazioni per la distribuzione delle applicazioni, consulta Application [Deployment Permissions and [Publishing](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) nella Developer Guide.AWS Serverless Application Repository *
## Definizione di un'applicazione annidata dal file system locale
È possibile definire applicazioni annidate utilizzando applicazioni archiviate nel file system locale. A tale scopo, è necessario specificare il percorso del file AWS SAM modello archiviato nel file system locale.
Di seguito è riportato un esempio di sezione modello SAM per un'applicazione locale annidata:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Se non sono presenti impostazioni dei parametri, è possibile omettere la `Parameters:` sezione del modello.
## Distribuzione di applicazioni annidate
È possibile distribuire l'applicazione annidata utilizzando il comando. AWS SAMCLI `sam deploy` Per ulteriori dettagli, consultare [Implementa la tua applicazione e le tue risorse con AWS SAM](serverless-deploying.md).
**Nota**
Quando si distribuisce un'applicazione che contiene applicazioni nidificate, è necessario confermare che contiene applicazioni nidificate. Puoi farlo passando `CAPABILITY_AUTO_EXPAND` all'[CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) o utilizzando il comando. [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI
*Per ulteriori informazioni sul riconoscimento delle applicazioni annidate, consulta la sezione [Riconoscimento dei ruoli IAM, delle politiche delle risorse e delle applicazioni annidate durante la distribuzione delle applicazioni](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) nella Guida per gli sviluppatori.AWS Serverless Application Repository *
# Gestisci eventi basati sul tempo con EventBridge Scheduler in AWS SAM
Il contenuto di questo argomento fornisce dettagli su cos'è Amazon EventBridge Scheduler, quali AWS SAM offerte di supporto, come creare eventi Scheduler ed esempi a cui puoi fare riferimento quando crei eventi Scheduler.
## Cos'è Amazon EventBridge Scheduler?
Usa EventBridge Scheduler per pianificare eventi nei tuoi AWS SAM modelli. Amazon EventBridge Scheduler è un servizio di pianificazione che consente di creare, avviare e gestire decine di milioni di eventi e attività in tutti i servizi. AWS Questo servizio è particolarmente utile per gli eventi legati al tempo. È possibile utilizzarlo per pianificare eventi e invocazioni ricorrenti basate sul tempo. Supporta anche eventi occasionali, nonché espressioni rate e chron con un'ora di inizio e di fine.
Per ulteriori informazioni su Amazon EventBridge Scheduler, consulta [What is Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)? nella Guida per l'utente di *EventBridge Scheduler.*
**Topics**
+ [
## Cos'è Amazon EventBridge Scheduler?
](#using-eventbridge-scheduler-intro)
+ [
## EventBridge Supporto Scheduler in AWS SAM
](#using-eventbridge-scheduler-sam-support)
+ [
## Creazione di eventi Scheduler EventBridge in AWS SAM
](#using-eventbridge-scheduler-sam-create)
+ [
## Esempi
](#using-eventbridge-scheduler-examples)
+ [
## Ulteriori informazioni
](#using-eventbridge-scheduler-learn)
## EventBridge Supporto Scheduler in AWS SAM
La specifica del modello AWS Serverless Application Model (AWS SAM) fornisce una sintassi semplice e abbreviata che è possibile utilizzare per pianificare eventi con EventBridge Scheduler for and. AWS Lambda AWS Step Functions
## Creazione di eventi Scheduler EventBridge in AWS SAM
Imposta la `ScheduleV2` proprietà come tipo di evento nel AWS SAM modello per definire l'evento EventBridge Scheduler. Questa proprietà supporta i tipi di `AWS::Serverless::StateMachine` risorse `AWS::Serverless::Function` and.
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge La pianificazione degli eventi di Scheduler supporta anche le *code di lettere morte (DLQ*) per gli eventi non elaborati. *Per ulteriori informazioni sulle code di lettere non scritte, vedere [Configurazione](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html) di una coda di lettere non scritte per Scheduler nella Guida per l'utente di Scheduler. EventBridge EventBridge *
Quando viene specificato un ARN DLQ AWS SAM , configura le autorizzazioni per la pianificazione dello Scheduler per inviare messaggi al DLQ. Quando non viene specificato un ARN DLQ AWS SAM , creerà la risorsa DLQ.
## Esempi
### Esempio di base di definizione di un EventBridge evento Scheduler con AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## Ulteriori informazioni
Per ulteriori informazioni sulla definizione della proprietà `ScheduleV2` EventBridge Scheduler, consulta:
+ [ScheduleV2](sam-property-function-schedulev2.md)per`AWS::Serverless::Function`.
+ [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md)per`AWS::Serverless::StateMachine`.
# Orchestrazione delle risorse con AWS SAM AWS Step Functions
È possibile utilizzarlo [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)per orchestrare AWS Lambda funzioni e altre AWS risorse per formare flussi di lavoro complessi e robusti. Step Functions per indicare all'applicazione quando e in quali condizioni vengono utilizzate le AWS risorse, ad esempio AWS Lambda le funzioni. Ciò semplifica il processo di creazione di flussi di lavoro complessi e robusti. Utilizzando[AWS::Serverless::StateMachine](sam-resource-statemachine.md), si definiscono le singole fasi del flusso di lavoro, si associano le risorse in ciascuna fase e quindi si mettono in sequenza questi passaggi. Puoi anche aggiungere transizioni e condizioni dove sono necessarie. Ciò semplifica il processo di creazione di un flusso di lavoro complesso e robusto.
**Nota**
Per gestire i AWS SAM modelli che contengono le macchine a stati Step Functions, è necessario utilizzare la versione 0.52.0 o successiva di. AWS SAMCLI Per verificare la versione in uso, esegui il comando. `sam --version`
Step Functions si basa sui concetti di [task](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) e [macchine a stati](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Definisci le macchine a stati utilizzando [Amazon States](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) Language basato su JSON. La [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) mostra una visualizzazione grafica della struttura della macchina a stati in modo da poter controllare visivamente la logica della macchina a stati e monitorare le esecuzioni.
Con il supporto Step Functions in AWS Serverless Application Model (AWS SAM), puoi fare quanto segue:
+ Definite le macchine a stati, direttamente all'interno di un AWS SAM modello o in un file separato
+ Crea ruoli di esecuzione delle macchine a stati tramite modelli di AWS SAM policy, policy in linea o policy gestite
+ Attiva esecuzioni di macchine a stati con API Gateway o EventBridge eventi Amazon, in base a una pianificazione all'interno di un AWS SAM modello o chiamando direttamente APIs
+ Utilizza i [modelli di AWS SAM policy disponibili per i modelli](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) di sviluppo Step Functions comuni.
## Esempio
Il seguente frammento di esempio tratto da un file AWS SAM modello definisce una macchina a stati Step Functions in un file di definizione. Tieni presente che il `my_state_machine.asl.json` file deve essere scritto in [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html).
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Per scaricare un' AWS SAM applicazione di esempio che include una macchina a stati Step Functions, consulta [Creare una macchina a stati Step Functions Using AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) nella *AWS Step Functions Developer Guide*.
## Ulteriori informazioni
Per saperne di più su Step Functions e sul suo utilizzo con AWS SAM, consulta quanto segue:
+ [Funzionamento di AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions e AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [Tutorial: Creare una macchina a stati Step Functions utilizzando AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM Specifiche: AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# Configura la firma del codice per la tua AWS SAM applicazione
Per garantire che venga distribuito solo codice affidabile, puoi utilizzare AWS SAM per abilitare la firma del codice con le tue applicazioni serverless. La firma del codice aiuta a garantire che il codice non sia stato alterato dopo la firma e che nelle funzioni Lambda vengano eseguiti solo pacchetti di codice firmati da editori affidabili. Questo aiuta a liberare le organizzazioni dall'onere di creare componenti gatekeeper nelle loro pipeline di implementazione.
Per ulteriori informazioni sulla firma del codice, consulta [Configurazione della firma del codice per le funzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) nella Guida per *AWS Lambda gli* sviluppatori.
Prima di poter configurare la firma del codice per la tua applicazione serverless, devi creare un profilo di firma utilizzando Signer. AWS Utilizzi questo profilo di firma per le seguenti attività:
1. **Creazione di una configurazione di firma del codice**: dichiara una [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)risorsa per specificare i profili di firma degli editori attendibili e impostare l'azione politica per i controlli di convalida. È possibile dichiarare questo oggetto nello stesso AWS SAM modello della funzione serverless, in un modello diverso o in un AWS SAM modello. CloudFormation Quindi abiliti la firma del codice per una funzione serverless specificando la [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn)proprietà della funzione con l'Amazon Resource Name (ARN) di [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)una risorsa.
1. **Firma del codice**: utilizza il [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html)comando [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)or con l'`--signing-profiles`opzione.
**Nota**
Per firmare correttamente il codice con i `sam deploy` comandi `sam package` o, è necessario abilitare il controllo delle versioni per il bucket Amazon S3 che usi con questi comandi. Se utilizzi il bucket Amazon S3 AWS SAM creato per te, il controllo delle versioni viene abilitato automaticamente. *Per ulteriori informazioni sul controllo delle versioni dei bucket Amazon S3 e istruzioni per abilitare il controllo delle versioni su un bucket Amazon S3 da te fornito, consulta Using versioning in Amazon S3 bucket nella [Amazon Simple Storage Service User Guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html).*
Quando distribuisci un'applicazione serverless, Lambda esegue controlli di convalida su tutte le funzioni per le quali hai abilitato la firma del codice. Lambda esegue anche controlli di convalida su tutti i livelli da cui dipendono tali funzioni. *Per ulteriori informazioni sui controlli di convalida di Lambda, consulta la convalida della [firma nella Guida per gli sviluppatori.](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid)AWS Lambda *
## Esempio
### Creazione di un profilo di firma
Per creare un profilo di firma, esegui il seguente comando:
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
Se il comando precedente ha esito positivo, viene restituito l'ARN del profilo di firma. Esempio:
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
Il `profileVersionArn` campo contiene l'ARN da utilizzare quando si crea la configurazione di firma del codice.
### Creazione di una configurazione di firma del codice e attivazione della firma del codice per una funzione
Il seguente AWS SAM modello di esempio dichiara una [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)risorsa e abilita la firma del codice per una funzione Lambda. In questo esempio, esiste un profilo affidabile e le distribuzioni vengono rifiutate se i controlli della firma hanno esito negativo.
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### Firma del codice
Puoi firmare il codice durante il pacchetto o la distribuzione dell'applicazione. Specificate l'`--signing-profiles`opzione con il `sam deploy` comando `sam package` o, come illustrato nei seguenti comandi di esempio.
Firma del codice della funzione al momento del pacchetto dell'applicazione:
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Firma sia il codice della funzione che il livello da cui dipende la funzione, durante la creazione del pacchetto dell'applicazione:
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Firma del codice funzionale e di un livello, quindi esecuzione di una distribuzione:
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**Nota**
Per firmare correttamente il codice con i `sam deploy` comandi `sam package` o, è necessario abilitare il controllo delle versioni per il bucket Amazon S3 che usi con questi comandi. Se utilizzi il bucket Amazon S3 AWS SAM creato per te, il controllo delle versioni viene abilitato automaticamente. *Per ulteriori informazioni sul controllo delle versioni dei bucket Amazon S3 e istruzioni per abilitare il controllo delle versioni su un bucket Amazon S3 da te fornito, consulta Using versioning in Amazon S3 bucket nella [Amazon Simple Storage Service User Guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html).*
## Fornire profili di firma con `sam deploy --guided`
Quando si esegue il `sam deploy --guided` comando con un'applicazione serverless configurata con la firma del codice, viene AWS SAM richiesto di fornire il profilo di firma da utilizzare per la firma del codice. Per ulteriori informazioni sui `sam deploy --guided` prompt, [sam deploy](sam-cli-command-reference-sam-deploy.md) consulta il riferimento ai comandi. AWS SAMCLI
# Convalida dei file AWS SAM modello
Convalida i tuoi modelli con. `sam validate` Attualmente, questo comando verifica che il modello fornito sia JSON/YAML valido. Come la maggior parte dei AWS SAMCLI comandi, per impostazione predefinita cerca un `template.[yaml|yml]` file nella directory di lavoro corrente. È possibile specificare un modello diverso file/location con l'`--template`opzione `-t` o.
Esempio:
```
$ sam validate
/template.yaml is a valid SAM Template
```
**Nota**
Il `sam validate` comando richiede la configurazione AWS delle credenziali. Per ulteriori informazioni, consulta [Configurazione del AWS SAMCLI](using-sam-cli-configure.md).
# Crea la tua applicazione con AWS SAM
Dopo aver aggiunto l'infrastruttura come codice (IaC) al AWS SAM modello, sarete pronti per iniziare a creare l'applicazione utilizzando il **sam build** comando. Questo comando crea artefatti di compilazione dai file nella directory del progetto dell'applicazione (ovvero il file AWS SAM modello, il codice dell'applicazione e qualsiasi file e dipendenza specifici del linguaggio applicabile). Questi elementi di build preparano l'applicazione serverless per le fasi successive dello sviluppo dell'applicazione, come il test locale e la distribuzione nel cloud. AWS Sia il test che la distribuzione utilizzano gli artefatti di build come input.
Puoi utilizzarlo **sam build** per creare la tua intera applicazione serverless. Inoltre, puoi creare build personalizzate, come quelle con funzioni, livelli o runtime personalizzati specifici. Per saperne di più su come e perché lo usi**sam build**, consulta gli argomenti di questa sezione. Per un'introduzione all'uso del `sam build` comando, vedere[Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md).
**Topics**
+ [
# Introduzione alla costruzione con AWS SAM
](using-sam-cli-build.md)
+ [
# Compilazione predefinita con AWS SAM
](serverless-sam-cli-using-build.md)
+ [
# Personalizza le build con AWS SAM
](building-lambda-functions.md)
# Introduzione alla costruzione con AWS SAM
Utilizzate il AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam build` per preparare l'applicazione serverless per le fasi successive del flusso di lavoro di sviluppo, come il test locale o la distribuzione su. Cloud AWS Questo comando crea una `.aws-sam` directory che struttura l'applicazione in un formato e in una posizione richiesti`sam local`. `sam deploy`
+ Per un'introduzione a AWS SAMCLI, vedere[Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli).
+ Per un elenco delle opzioni di `sam build` comando, vedere[sam build](sam-cli-command-reference-sam-build.md).
+ Per un esempio di utilizzo `sam build` durante un tipico flusso di lavoro di sviluppo, vedi[Fase 2: Crea la tua applicazione](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build).
**Nota**
L'utilizzo `sam build` richiede di iniziare con i componenti di base di un'applicazione serverless sulla macchina di sviluppo. Ciò include un AWS SAM modello, un codice di AWS Lambda funzione e qualsiasi file e dipendenza specifici del linguaggio. Per ulteriori informazioni, consulta [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md).
**Topics**
+ [
## Creazione di applicazioni con sam build
](#using-sam-cli-build-apps)
+ [
## Test e distribuzione locali
](#using-sam-cli-build-test-deploy)
+ [
## Best practice
](#using-sam-cli-build-best)
+ [
## Opzioni per sam build
](#using-sam-cli-build-options)
+ [
## Risoluzione dei problemi
](#using-sam-cli-build-troubleshooting)
+ [
## Esempi
](#using-sam-cli-build-examples)
+ [
## Ulteriori informazioni
](#using-sam-cli-build-learn)
## Creazione di applicazioni con sam build
Prima dell'uso`sam build`, valuta la possibilità di configurare quanto segue:
1. **Funzioni e livelli Lambda**: il `sam build` comando può creare funzioni e livelli Lambda. Per ulteriori informazioni sui layer Lambda, consulta. [Creazione di livelli Lambda in AWS SAM](building-layers.md)
1. **Lambda runtime**: il *runtime* fornisce un ambiente specifico del linguaggio che esegue la funzione in un ambiente di esecuzione quando viene richiamata. È possibile configurare runtime nativi e personalizzati.
1. **Runtime nativo**: crea le tue funzioni Lambda in un runtime Lambda supportato e crea funzioni per utilizzare un runtime Lambda nativo in. Cloud AWS
1. **Runtime personalizzato**: crea le tue funzioni Lambda utilizzando qualsiasi linguaggio di programmazione e crea il tuo runtime utilizzando un processo personalizzato definito in un builder makefile o di terze parti come. esbuild Per ulteriori informazioni, consulta [Creazione di funzioni Lambda con runtime personalizzati in AWS SAM](building-custom-runtimes.md).
1. **Tipo di pacchetto Lambda**: le funzioni Lambda possono essere incluse nei seguenti tipi di pacchetti di distribuzione Lambda:
1. **Archivio di file.zip**: contiene il codice dell'applicazione e le sue dipendenze.
1. **Immagine del contenitore**: contiene il sistema operativo di base, il runtime, le estensioni Lambda, il codice dell'applicazione e le relative dipendenze.
Queste impostazioni dell'applicazione possono essere configurate durante l'inizializzazione di un'applicazione utilizzando. `sam init`
+ Per ulteriori informazioni sull'utilizzo`sam init`, vedere. [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md)
+ Per ulteriori informazioni sulla configurazione di queste impostazioni nell'applicazione, consulta[Compilazione predefinita con AWS SAM](serverless-sam-cli-using-build.md).
**Per creare un'applicazione**
1. `cd`alla radice del tuo progetto. Questa è la stessa posizione del AWS SAM modello.
```
$ cd sam-app
```
1. Esegui il seguente codice:
```
sam-app $ sam build
```
**Nota**
Un'opzione comunemente usata è`--use-container`. Per ulteriori informazioni, consulta [Creazione di una funzione Lambda all'interno di un contenitore fornito](#using-sam-cli-build-options-container).
Di seguito è riportato un esempio dell' AWS SAMCLIoutput:
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder: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
```
1. Quindi AWS SAMCLI crea una cartella di `.aws-sam` compilazione. Di seguito è riportato un esempio:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
A seconda di come è configurata l'applicazione, AWS SAMCLI esegue le seguenti operazioni:
1. Scarica, installa e organizza le dipendenze nella directory. `.aws-sam/build`
1. Prepara il codice Lambda. Ciò può includere la compilazione del codice, la creazione di file binari eseguibili e la creazione di immagini di container.
1. Copia gli artefatti della build nella directory. `.aws-sam` Il formato varierà in base al tipo di pacchetto dell'applicazione.
1. Per i tipi di pacchetti.zip, gli artefatti non sono ancora compressi, quindi possono essere utilizzati per i test locali. Comprime l' AWS SAMCLIapplicazione durante l'utilizzo. `sam deploy`
1. Per i tipi di pacchetto di immagini del contenitore, un'immagine del contenitore viene creata localmente e referenziata nel `.aws-sam/build.toml` file.
1. Copia il AWS SAM modello nella `.aws-sam` directory e lo modifica con nuovi percorsi di file quando necessario.
Di seguito sono riportati i componenti principali che costituiscono gli artefatti di compilazione presenti nella directory: `.aws-sam`
+ **La directory di compilazione**: contiene le funzioni e i livelli Lambda strutturati indipendentemente l'uno dall'altro. Ciò si traduce in una struttura unica per ogni funzione o livello nella `.aws-sam/build` directory.
+ **Il AWS SAM modello**: modificato con valori aggiornati in base alle modifiche durante il processo di creazione.
+ **Il file build.toml: un file** di configurazione che contiene le impostazioni di build utilizzate da. AWS SAMCLI
## Test e distribuzione locali
Quando si eseguono test locali con `sam local` o si distribuiscono con`sam deploy`, AWS SAMCLI esegue le seguenti operazioni:
1. Innanzitutto verifica se esiste una `.aws-sam` directory e se un AWS SAM modello si trova all'interno di quella directory. Se queste condizioni sono soddisfatte, la AWS SAMCLI considera la directory principale dell'applicazione.
1. Se queste condizioni non sono soddisfatte, AWS SAMCLI considera la posizione originale del AWS SAM modello come cartella principale dell'applicazione.
Durante lo sviluppo, se vengono apportate modifiche ai file dell'applicazione originale, esegui `sam build` per aggiornare la `.aws-sam` directory prima di eseguire il test a livello locale.
## Best practice
+ Non modificare alcun codice contenuto nella `.aws-sam/build` directory. Aggiorna invece il codice sorgente originale nella cartella del progetto ed `sam build` esegui per aggiornare la `.aws-sam/build` directory.
+ Quando modifichi i file originali, esegui `sam build` per aggiornare la `.aws-sam/build` directory.
+ Potresti voler fare riferimento AWS SAMCLI alla directory principale originale del tuo progetto anziché alla `.aws-sam` directory, ad esempio durante lo sviluppo e il test con`sam local`. Eliminate la `.aws-sam` directory o il AWS SAM modello nella `.aws-sam` directory per fare in modo che AWS SAMCLI riconoscano la directory del progetto originale come cartella principale del progetto. Quando sei pronto, esegui di `sam build` nuovo per creare la `.aws-sam` directory.
+ Quando esegui`sam build`, la `.aws-sam/build` directory viene sovrascritta ogni volta. La `.aws-sam` directory no. Se desideri archiviare file, come i registri, memorizzali in `.aws-sam` per evitare che vengano sovrascritti.
## Opzioni per sam build
### Costruire un'unica risorsa
Fornisci l'ID logico della risorsa per creare solo quella risorsa. Di seguito è riportato un esempio:
```
$ sam build HelloWorldFunction
```
Per creare una risorsa di un'applicazione o di uno stack annidato, fornisci l'ID logico dell'applicazione o dello stack insieme all'ID logico della risorsa utilizzando il formato: `/`
```
$ sam build MyNestedStack/MyFunction
```
### Creazione di una funzione Lambda all'interno di un contenitore fornito
L'`--use-container`opzione scarica un'immagine del contenitore e la utilizza per creare le funzioni Lambda. Il contenitore locale viene quindi referenziato nel file`.aws-sam/build.toml`.
Questa opzione deve Docker essere installata. Per istruzioni, consulta [Installazione di Docker](install-docker.md).
Di seguito è riportato un esempio di questo comando:
```
$ sam build --use-container
```
È possibile specificare l'immagine del contenitore da utilizzare con l'`--build-image`opzione. Di seguito è riportato un esempio:
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
Per specificare l'immagine del contenitore da utilizzare per una singola funzione, fornite l'ID logico della funzione. Di seguito è riportato un esempio:
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### Passa le variabili di ambiente al contenitore di compilazione
Usa `--container-env-var` per passare le variabili di ambiente al contenitore di compilazione. Di seguito è riportato un esempio:
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
Per passare le variabili di ambiente da un file, usa l'`--container-env-var-file`opzione. Di seguito è riportato un esempio:
```
$ sam build --use-container --container-env-var-file
```
Esempio del `env.json` file:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### Accelera la creazione di applicazioni che contengono più funzioni
Quando viene eseguita `sam build` su un'applicazione con più funzioni, AWS SAMCLI crea ogni funzione una alla volta. Per velocizzare il processo di compilazione, utilizzate l'`--parallel`opzione. Questo crea tutte le funzioni e i livelli contemporaneamente.
Di seguito è riportato un esempio di questo comando:
```
$ sam build —-parallel
```
### Accelera i tempi di compilazione creando il progetto nella cartella dei sorgenti
Per i runtime e i metodi di compilazione supportati, puoi utilizzare l'`--build-in-source`opzione per creare il tuo progetto direttamente nella cartella dei sorgenti. Per impostazione predefinita, AWS SAM CLI le build si trovano in una directory temporanea, che prevede la copia del codice sorgente e dei file di progetto. Con`--build-in-source`, AWS SAM CLI le build vengono create direttamente nella cartella di origine, il che accelera il processo di compilazione eliminando la necessità di copiare i file in una directory temporanea.
Per un elenco dei runtime e dei metodi di compilazione supportati, consulta. `--build-in-source`
## Risoluzione dei problemi
Per risolvere il problema AWS SAMCLI, vedi. [AWS SAMCLIrisoluzione dei problemi](sam-cli-troubleshooting.md)
## Esempi
### Creazione di un'applicazione che utilizza un runtime nativo e un tipo di pacchetto.zip
Per questo esempio, vedi[Tutorial: Implementa un'applicazione Hello World con AWS SAM](serverless-getting-started-hello-world.md).
### Creazione di un'applicazione che utilizza un tipo di pacchetto di immagini e runtime nativi
Per prima cosa, eseguiamo `sam init` l'inizializzazione di una nuova applicazione. Durante il flusso interattivo, selezioniamo il tipo di `Image` pacchetto. Di seguito è riportato un esempio:
```
$ 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
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
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]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
AWS SAMCLIinizializza un'applicazione e crea la seguente directory di progetto:
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
Successivamente, corriamo `sam build` a creare la nostra applicazione:
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
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
```
### Creazione di un'applicazione che includa un linguaggio di programmazione compilato
In questo esempio, creiamo un'applicazione che contiene una funzione Lambda utilizzando il Go runtime.
Innanzitutto, inizializziamo una nuova applicazione utilizzando `sam init` e configuriamo la nostra applicazione per utilizzare: Go
```
$ 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?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
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]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
Quindi AWS SAMCLI inizializza l'applicazione. Di seguito è riportato un esempio della struttura delle cartelle dell'applicazione:
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
Facciamo riferimento al `README.md` file per i requisiti di questa applicazione.
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
Successivamente, corriamo `sam local invoke` per testare la nostra funzione. Questo comando ha un errore poiché non Go è installato sul nostro computer locale:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
Successivamente, corriamo `sam build` a creare la nostra applicazione. Riscontriamo un errore poiché non Go è installato sul nostro computer locale:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
Sebbene sia possibile configurare la nostra macchina locale per creare correttamente la nostra funzione, utilizziamo invece l'`--use-container`opzione con`sam build`. AWS SAMCLIScarica l'immagine di un contenitore, crea la nostra funzione usando quella nativa GoModulesBuilder e copia il file binario risultante `.aws-sam/build/HelloWorldFunction` nella nostra directory.
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
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
```
Di seguito è riportato un esempio della `.aws-sam` directory:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
Successivamente, corriamo`sam local invoke`. La nostra funzione è stata richiamata con successo:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## Ulteriori informazioni
Per ulteriori informazioni sull'utilizzo del `sam build` comando, consulta quanto segue:
+ **[Apprendimento AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** — Serie Serverless Land «Learning AWS SAM» suYouTube.
+ **[Apprendimento AWS SAM \$1 sam build \$1 E3](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** — Continuata la serie Serverless Land «Learning AWS SAM». YouTube
+ **[AWS SAM build: come fornisce gli artefatti per l'implementazione (Sessions With SAM S2E8) — Sessioni con](https://www.youtube.com/watch?v=bNbBd6XoDHg)** serie attivate. AWS SAM YouTube
+ **[AWS SAM build personalizzate: come usare Makefile per personalizzare le build in SAM (S2E9) — Sessioni con serie](https://www.youtube.com/watch?v=wpccutnSbAk)** accese. AWS SAM YouTube
# Compilazione predefinita con AWS SAM
Per creare la tua applicazione serverless, usa il `sam build` comando. Questo comando raccoglie anche gli elementi di compilazione delle dipendenze dell'applicazione e li colloca nel formato e nella posizione corretti per le fasi successive, come il test, la creazione di pacchetti e la distribuzione a livello locale.
È possibile specificare le dipendenze dell'applicazione in un file manifest, ad esempio `requirements.txt` (Python) `package.json` o (Node.js), oppure utilizzando `Layers` la proprietà di una risorsa funzione. La `Layers` proprietà contiene un elenco di risorse di [AWS Lambda livello](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) da cui dipende la funzione Lambda.
Il formato degli elementi di compilazione dell'applicazione dipende dalla proprietà di ciascuna funzione. `PackageType` Le opzioni per questa proprietà sono:
+ **`Zip`**— Un archivio di file.zip, che contiene il codice dell'applicazione e le sue dipendenze. Se impacchettate il codice come archivio di file.zip, dovete specificare un runtime Lambda per la funzione.
+ **`Image`**— Un'immagine del contenitore, che include il sistema operativo di base, il runtime e le estensioni, oltre al codice dell'applicazione e alle sue dipendenze.
*Per ulteriori informazioni sui tipi di pacchetti Lambda, consulta [Pacchetti di distribuzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) nella Developer Guide.AWS Lambda *
**Topics**
+ [
## Creazione di un archivio di file.zip
](#build-zip-archive)
+ [
## Creazione di un'immagine di contenitore
](#build-container-image)
+ [
## File variabile di ambiente del contenitore
](#serverless-sam-cli-using-container-environment-file)
+ [
## Accelera i tempi di compilazione creando il progetto nella cartella dei sorgenti
](#serverless-sam-cli-using-build-in-source)
+ [
## Esempi
](#building-applications-examples)
+ [
## Costruire funzioni al di fuori di AWS SAM
](#building-applications-skip)
## Creazione di un archivio di file.zip
Per creare un'applicazione serverless come archivio di file.zip, dichiarate `PackageType: Zip` di utilizzare la funzione serverless.
AWS SAM [crea l'applicazione per l'architettura specificata.](sam-resource-function.md#sam-function-architectures) Se non si specifica un'architettura, AWS SAM utilizza `x86_64` per impostazione predefinita.
Se la tua funzione Lambda dipende da pacchetti con programmi compilati nativamente, usa il flag. `--use-container` Questo flag compila localmente le tue funzioni in un contenitore che si comporta come un ambiente Lambda, quindi sono nel formato giusto quando le distribuisci sul Cloud. AWS
Quando utilizzi l'`--use-container`opzione, per impostazione predefinita AWS SAM estrae l'immagine del contenitore da [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) Public. Se desideri estrarre un'immagine del contenitore da un altro repository o per una versione specifica della AWS SAM CLI, puoi utilizzare l'`--build-image`opzione e fornire l'URI di un'immagine contenitore alternativa. Di seguito sono riportati due comandi di esempio per la creazione di applicazioni che utilizzano immagini di contenitori da una versione specifica della AWS SAM CLI:
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
Per ulteriori esempi di creazione di un'applicazione di archiviazione di file con estensione zip, consultate la sezione Esempi più avanti in questo argomento.
## Creazione di un'immagine di contenitore
Per creare un'applicazione serverless come immagine contenitore, dichiarate di utilizzare `PackageType: Image` la funzione serverless. È inoltre necessario dichiarare l'attributo `Metadata` resource con le seguenti voci:
`Dockerfile`
Il nome del Dockerfile associato alla funzione Lambda.
`DockerContext`
La posizione del Dockerfile.
`DockerTag`
(Facoltativo) Un tag da applicare all'immagine costruita.
`DockerBuildArgs`
Crea argomenti per la compilazione.
AWS SAMCLINon oscura né offusca le informazioni che includi negli argomenti. `DockerBuildArgs` Si consiglia vivamente di non utilizzare questa sezione per archiviare informazioni riservate, ad esempio password o segreti.
Di seguito è riportato un esempio `Metadata` di sezione relativa agli attributi delle risorse:
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Per scaricare un'applicazione di esempio configurata con il tipo di `Image` pacchetto, consulta[Tutorial: Implementa un'applicazione Hello World con AWS SAM](serverless-getting-started-hello-world.md). Quando viene richiesto il tipo di pacchetto da installare, scegliete`Image`.
**Nota**
Se specifichi un'immagine di base multiarchitettura nel tuo Dockerfile, AWS SAM crea l'immagine del contenitore per l'architettura della tua macchina host. Per creare per un'architettura diversa, specifica un'immagine di base che utilizzi l'architettura di destinazione specifica.
## File variabile di ambiente del contenitore
Per fornire un file JSON che contenga variabili di ambiente per il contenitore di compilazione, usa l'`--container-env-var-file`argomento con il `sam build` comando. Puoi fornire una singola variabile di ambiente che si applica a tutte le risorse serverless o variabili di ambiente diverse per ogni risorsa.
### Formato
Il formato per il passaggio delle variabili di ambiente a un contenitore di build dipende dal numero di variabili di ambiente fornite per le risorse.
Per fornire un'unica variabile di ambiente per tutte le risorse, specifica un `Parameters` oggetto come il seguente:
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
Per fornire variabili di ambiente diverse per ogni risorsa, specificate gli oggetti per ogni risorsa come segue:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
Salvate le variabili di ambiente come file, ad esempio denominato`env.json`. Il comando seguente utilizza questo file per passare le variabili di ambiente al contenitore di compilazione:
```
sam build --use-container --container-env-var-file env.json
```
### Priorità
+ Le variabili di ambiente fornite per risorse specifiche hanno la precedenza sulla singola variabile di ambiente per tutte le risorse.
+ Le variabili di ambiente fornite nella riga di comando hanno la precedenza sulle variabili di ambiente in un file.
## Accelera i tempi di compilazione creando il progetto nella cartella dei sorgenti
Per i runtime e i metodi di compilazione supportati, puoi utilizzare l'`--build-in-source`opzione per creare il tuo progetto direttamente nella cartella di origine. Per impostazione predefinita, AWS SAM CLI le build si trovano in una directory temporanea, che prevede la copia del codice sorgente e dei file di progetto. Con`--build-in-source`, AWS SAM CLI le build vengono create direttamente nella cartella di origine, il che accelera il processo di compilazione eliminando la necessità di copiare i file in una directory temporanea.
Per un elenco dei runtime e dei metodi di compilazione supportati, consulta. `--build-in-source`
## Esempi
### Esempio 1: archivio di file.zip
I seguenti `sam build` comandi creano un archivio di file.zip:
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### Esempio 2: immagine del contenitore
Il seguente AWS SAM modello viene creato come immagine del contenitore:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Di seguito è riportato un esempio di Dockerfile:
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### Esempio 3: npm ci
Per le applicazioni Node.js, è possibile utilizzare `npm ci` invece di `npm install` installare le dipendenze. Per utilizzarlo`npm ci`, specifica `UseNpmCi: True` sotto `BuildProperties` nell'attributo `Metadata` resource della funzione Lambda. Per essere utilizzata`npm ci`, l'applicazione deve avere un `npm-shrinkwrap.json` file `package-lock.json` or presente nella funzione `CodeUri` for your Lambda.
L'esempio seguente utilizza `npm ci` per installare le dipendenze durante l'esecuzione: `sam build`
```
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
Metadata:
BuildProperties:
UseNpmCi: True
```
### Pacchetti principali in Python
Per le applicazioni Python, puoi preservare la struttura del pacchetto durante il processo di compilazione per abilitare le importazioni assolute. Per preservare la struttura del pacchetto, specifica `ParentPackageMode` sotto `BuildProperties` nell'attributo `Metadata` resource della funzione Lambda.
L'esempio seguente conserva la struttura del `app` pacchetto durante l'esecuzione: `sam build`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
Con questa configurazione, il codice può utilizzare importazioni assolute come `from app.utils import logger` invece di importazioni relative come`from .utils import logger`.
## Costruire funzioni al di fuori di AWS SAM
Per impostazione predefinita, quando si esegue**sam build**, AWS SAM crea tutte le risorse funzionali. Altre opzioni includono:
+ **Costruisci tutte le risorse funzionali all'esterno di AWS SAM**: se crei tutte le tue risorse funzionali manualmente o tramite un altro strumento, non **sam build** è necessario. Puoi saltare **sam build** e passare alla fase successiva del processo, ad esempio l'esecuzione di test locali o la distribuzione dell'applicazione.
+ **Crea alcune risorse funzionali all'esterno AWS SAM**: se desideri AWS SAM creare alcune delle tue risorse funzionali con altre risorse funzionali integrate all'esterno AWS SAM, puoi specificarlo nel tuo AWS SAM modello.
### Crea alcune risorse funzionali al di fuori di AWS SAM
Per fare in modo che una funzione venga AWS SAM ignorata durante l'utilizzo**sam build**, configura quanto segue nel AWS SAM modello:
1. Aggiungi la proprietà `SkipBuild: True` dei metadati alla tua funzione.
1. Specificate il percorso delle risorse funzionali integrate.
Ecco un esempio, con `TestFunction` configurato per essere ignorato. Le sue risorse integrate si trovano in`built-resources/TestFunction.zip`.
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
Ora, quando corri**sam build**, AWS SAM farà quanto segue:
1. AWS SAM salterà le funzioni configurate con`SkipBuild: True`.
1. AWS SAM creerà tutte le altre risorse funzionali e le memorizzerà nella directory di `.aws-sam` compilazione.
1. Per le funzioni ignorate, il relativo modello nella directory di `.aws-sam` compilazione verrà automaticamente aggiornato per fare riferimento al percorso specificato delle risorse delle funzioni create.
Ecco un esempio del modello memorizzato nella cache per `TestFunction` nella directory di `.aws-sam` compilazione:
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# 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
```