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à. # 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).