

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

# Cos'è il AWS Serverless Application Model (AWS SAM)?
<a name="what-is-sam"></a>

AWS Serverless Application Model (AWS SAM) è un framework open source per la creazione di applicazioni serverless utilizzando l'infrastruttura come codice (IaC). Con AWS SAM la sua sintassi abbreviata, gli sviluppatori dichiarano [CloudFormation](https://aws.amazon.com/cloudformation)risorse e risorse serverless specializzate che vengono trasformate in infrastruttura durante l'implementazione. Quando lavori con AWS SAM, interagirai con:

1. AWS SAM CLI- Uno strumento da riga di comando che consente di sviluppare, testare localmente e distribuire applicazioni serverless.

1. AWS SAM Modello: un'estensione CloudFormation che fornisce una sintassi semplificata per la definizione di risorse serverless.

Quando si utilizza il **sam init** comando, viene creata una directory di progetto, denominata AWS SAM progetto, che in genere include il AWS SAM modello, il codice dell'applicazione e altri file di configurazione.

## Quando usare AWS SAM
<a name="when-to-use-sam"></a>

AWS SAM è una soluzione IaC ideale per scenari in cui si desidera uno sviluppo serverless semplificato con tutta la potenza di. CloudFormation Ad esempio, è possibile utilizzare SAM per:
+ **Applicazioni serverless:** puoi utilizzare SAM per definire rapidamente AWS Lambda funzioni, funzioni durevoli Lambda, Amazon API APIs Gateway, tabelle Amazon DynamoDB e altre risorse serverless con codice minimo.
+ **CloudFormation miglioramento:** puoi combinare SAM con CloudFormation modelli esistenti per aggiungere componenti serverless all'infrastruttura tradizionale. Le risorse SAM funzionano insieme alle CloudFormation risorse standard nello stesso modello.
+ **Sviluppo e test locali:** puoi utilizzare SAM CLI per testare le funzioni Lambda localmente, simulare gli endpoint API Gateway ed eseguire il debug di applicazioni serverless sulla tua macchina di sviluppo prima della distribuzione su. AWS
+ **CI/CD per sistemi serverless:** è possibile creare pipeline di distribuzione utilizzando modelli SAM che generano automaticamente l'infrastruttura necessaria per gli ambienti di staging e produzione. CloudFormation 
+ **Migrazione da risorse create dalla console:** è possibile convertire le funzioni Lambda e le risorse API Gateway create nella console di AWS gestione in infrastruttura come codice utilizzando modelli SAM.

**Confronto AWS SAM con altri strumenti IAc**
+ Utilizza SAM invece di CloudFormation semplificare le definizioni delle risorse serverless mantenendo la compatibilità dei modelli.
+ Utilizza SAM anziché AWS CDK se preferisci un approccio dichiarativo alla descrizione dell'infrastruttura piuttosto che uno programmatico.
+ Combina SAM con le funzionalità AWS CDK di test locali di SAM CLI per migliorare le tue applicazioni CDK.

## Funzionalità principali
<a name="what-is-sam-feature"></a>

AWS SAM offre una serie di vantaggi che migliorano l'esperienza degli sviluppatori consentendoti di: 

**Definite rapidamente il codice dell'infrastruttura applicativa, utilizzando meno codice**  
Crea AWS SAM modelli per definire il codice dell'infrastruttura applicativa serverless. Implementa i tuoi modelli direttamente per CloudFormation fornire le tue risorse.

**Gestisci le tue applicazioni serverless durante l'intero ciclo di sviluppo**  
Utilizzalo AWS SAMCLI per gestire la tua applicazione serverless durante le fasi di creazione, creazione, distribuzione, test e monitoraggio del ciclo di vita dello sviluppo. Per ulteriori informazioni, consulta [AWS SAM CLI](using-sam-cli.md).

**Fornisci rapidamente le autorizzazioni tra le risorse con i connettori AWS SAM **  
Usa i AWS SAM connettori nei tuoi AWS SAM modelli per definire le autorizzazioni tra le tue AWS risorse. AWS SAM trasforma il tuo codice nelle autorizzazioni IAM necessarie per facilitare il tuo intento. Per ulteriori informazioni, consulta [Gestione delle autorizzazioni delle risorse con i connettori AWS SAM](managing-permissions-connectors.md).

**Sincronizza continuamente le modifiche locali nel cloud durante lo sviluppo**  
Usa il AWS SAMCLI **sam sync** comando per sincronizzare automaticamente le modifiche locali nel cloud, velocizzando i flussi di lavoro di sviluppo e test sul cloud. Per ulteriori informazioni, consulta [Introduzione all'uso sam sync della sincronizzazione con Cloud AWS](using-sam-cli-sync.md).

**Gestisci le tue applicazioni serverless Terraform**  
Usa il AWS SAMCLI per eseguire il debug e il test locali delle funzioni e dei livelli Lambda. Per ulteriori informazioni, consulta [AWS SAMCLITerraformsupporto](terraform-support.md).

## Informazioni correlate
<a name="w2aab5c15"></a>
+ Per informazioni su come funziona, consulta AWS SAM . [Come funziona AWS SAM](what-is-sam-overview.md)
+ Per iniziare a usare AWS SAM, consulta[Guida introduttiva con AWS SAM](serverless-getting-started.md). 
+ Per una panoramica su come AWS SAM creare un'applicazione serverless, consulta[Come usare AWS SAM](chapter-using-sam.md#chapter-using-sam.title).

# Come funziona AWS SAM
<a name="what-is-sam-overview"></a>

Quando lavori con AWS SAM to per creare un'applicazione serverless, interagirai con i seguenti componenti:

1. **[AWS SAM modello](sam-specification.md)**— Un file importante che definisce le AWS risorse. Questo modello include la **specifica del AWS SAM modello**, il framework open source dotato di una sintassi abbreviata semplificata che consente di definire le funzioni, gli eventi APIs, le configurazioni e le autorizzazioni dell'applicazione serverless. Questo file si trova nel AWS SAM progetto, che è la cartella dell'applicazione che viene creata quando si esegue il comando. **sam init**

1. **[AWS SAM CLI](using-sam-cli.md)**— Uno strumento da riga di comando che puoi utilizzare con il tuo AWS SAM progetto e che supporta integrazioni di terze parti per creare ed eseguire applicazioni serverless. AWS SAMCLIÈ lo strumento che usi per eseguire comandi sul tuo AWS SAM progetto e alla fine trasformarlo in un'applicazione serverless.

Per esprimere risorse, mappature dei sorgenti degli eventi e altre proprietà che definiscono l'applicazione serverless, è necessario definire le risorse e sviluppare l'applicazione nel AWS SAM modello e in altri file del progetto. AWS SAM È possibile utilizzare i comandi AWS SAMCLI per eseguire i comandi sul AWS SAM progetto, ovvero inizializzare, creare, testare e distribuire l'applicazione serverless.

**Sei nuovo nel mondo serverless?**  
Ti consigliamo di recensire[Concetti serverless per AWS Serverless Application Model](what-is-concepts.md).

## Quali sono le specifiche del AWS SAM modello?
<a name="what-is-sam-template-spec"></a>

La specifica del AWS SAM modello è un framework open source che è possibile utilizzare per definire e gestire il codice dell'infrastruttura applicativa serverless. La specifica del AWS SAM modello è:
+ **Integrato AWS CloudFormation**: puoi utilizzare la CloudFormation sintassi direttamente nel tuo AWS SAM modello, sfruttando il suo ampio supporto per le configurazioni di risorse e proprietà. Se lo conoscete già CloudFormation, non è necessario imparare a usare un nuovo servizio per gestire il codice dell'infrastruttura delle applicazioni.
+ **Un'estensione di CloudFormation**: AWS SAM offre una sintassi unica che si concentra specificamente sull'accelerazione dello sviluppo serverless. È possibile utilizzare sia la CloudFormation AWS SAM sintassi che all'interno dello stesso modello.
+ **Una sintassi astratta e abbreviata**: utilizzando la AWS SAM sintassi, è possibile definire l'infrastruttura rapidamente, con un minor numero di righe di codice e con una minore possibilità di errori. La sua sintassi è particolarmente curata per eliminare la complessità della definizione dell'infrastruttura applicativa serverless.
+ **Trasformazionale**: AWS SAM esegue il complesso lavoro di trasformazione del modello nel codice necessario per il provisioning dell'infrastruttura. CloudFormation

## Cosa sono il AWS SAM progetto e il modello? AWS SAM
<a name="what-is-sam-template"></a>

Il AWS SAM progetto include il AWS SAM modello che contiene le specifiche del AWS SAM modello. Questa specifica è il framework open source utilizzato per definire l'infrastruttura applicativa serverless AWS, con alcuni componenti aggiuntivi che ne semplificano l'utilizzo. In questo senso, i AWS SAM modelli sono un'estensione dei CloudFormation modelli.

Ecco un esempio di applicazione serverless di base. Questa applicazione elabora le richieste per ottenere tutti gli elementi da un database tramite una richiesta HTTP. Consiste delle seguenti parti:

1. Una funzione che contiene la logica per elaborare la richiesta.

1. Un'API HTTP che funge da comunicazione tra il client (richiedente) e l'applicazione.

1. Un database per memorizzare gli articoli.

1. Autorizzazioni per l'esecuzione sicura dell'applicazione.

![\[Architettura applicativa di una semplice applicazione serverless.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-06.png)


Il codice di infrastruttura di questa applicazione può essere definito nel seguente AWS SAM modello:

```
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::Serverless-2016-10-31
Resources:
  getAllItemsFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/get-all-items.getAllItemsHandler
      Runtime: nodejs20.x
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /
            Method: GET
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: SampleTable
          Permissions:
            - Read
  SampleTable:
    Type: AWS::Serverless::SimpleTable
```

In 23 righe di codice, viene definita la seguente infrastruttura:
+ Una funzione che utilizza il AWS Lambda servizio.
+ Un'API HTTP che utilizza il servizio Amazon API Gateway.
+ Un database che utilizza il servizio Amazon DynamoDB.
+ Le autorizzazioni AWS Identity and Access Management (IAM) necessarie per consentire a questi servizi di interagire tra loro.

Per effettuare il provisioning di questa infrastruttura, il modello viene distribuito su. CloudFormation Durante la distribuzione, AWS SAM trasforma le 23 righe di codice nella CloudFormation sintassi richiesta per generare queste risorse. AWS Il CloudFormation modello trasformato contiene oltre 200 righe di codice\$1

### CloudFormation Modello trasformato
<a name="what-is-sam-template-example-cfn"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "getAllItemsFunction": {
      "Type": "AWS::Lambda::Function",
      "Metadata": {
        "SamResourceId": "getAllItemsFunction"
      },
      "Properties": {
        "Code": {
          "S3Bucket": "amzn-s3-demo-source-bucket-1a4x26zbcdkqr",
          "S3Key": "what-is-app/a6f856abf1b2c4f7488c09b367540b5b"
        },
        "Handler": "src/get-all-items.getAllItemsHandler",
        "Role": {
          "Fn::GetAtt": [
            "getAllItemsFunctionRole",
            "Arn"
          ]
        },
        "Runtime": "nodejs12.x",
        "Tags": [
          {
            "Key": "lambda:createdBy",
            "Value": "SAM"
          }
        ]
      }
    },
    "getAllItemsFunctionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "lambda.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [
          "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
        ],
        "Tags": [
          {
            "Key": "lambda:createdBy",
            "Value": "SAM"
          }
        ]
      }
    },
    "getAllItemsFunctionApiPermission": {
      "Type": "AWS::Lambda::Permission",
      "Properties": {
        "Action": "lambda:InvokeFunction",
        "FunctionName": {
          "Ref": "getAllItemsFunction"
        },
        "Principal": "apigateway.amazonaws.com",
        "SourceArn": {
          "Fn::Sub": [
            "arn:${AWS::Partition}:execute-api:${AWS::Region}:${AWS::AccountId}:${__ApiId__}/${__Stage__}/GET/",
            {
              "__ApiId__": {
                "Ref": "ServerlessHttpApi"
              },
              "__Stage__": "*"
            }
          ]
        }
      }
    },
    "ServerlessHttpApi": {
      "Type": "AWS::ApiGatewayV2::Api",
      "Properties": {
        "Body": {
          "info": {
            "version": "1.0",
            "title": {
              "Ref": "AWS::StackName"
            }
          },
          "paths": {
            "/": {
              "get": {
                "x-amazon-apigateway-integration": {
                  "httpMethod": "POST",
                  "type": "aws_proxy",
                  "uri": {
                    "Fn::Sub": "arn:${AWS::Partition}:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${getAllItemsFunction.Arn}/invocations"
                  },
                  "payloadFormatVersion": "2.0"
                },
                "responses": {}
              }
            }
          },
          "openapi": "3.0.1",
          "tags": [
            {
              "name": "httpapi:createdBy",
              "x-amazon-apigateway-tag-value": "SAM"
            }
          ]
        }
      }
    },
    "ServerlessHttpApiApiGatewayDefaultStage": {
      "Type": "AWS::ApiGatewayV2::Stage",
      "Properties": {
        "ApiId": {
          "Ref": "ServerlessHttpApi"
        },
        "StageName": "$default",
        "Tags": {
          "httpapi:createdBy": "SAM"
        },
        "AutoDeploy": true
      }
    },
    "SampleTable": {
      "Type": "AWS::DynamoDB::Table",
      "Metadata": {
        "SamResourceId": "SampleTable"
      },
      "Properties": {
        "AttributeDefinitions": [
          {
            "AttributeName": "id",
            "AttributeType": "S"
          }
        ],
        "KeySchema": [
          {
            "AttributeName": "id",
            "KeyType": "HASH"
          }
        ],
        "BillingMode": "PAY_PER_REQUEST"
      }
    },
    "getAllItemsFunctionMyConnPolicy": {
      "Type": "AWS::IAM::ManagedPolicy",
      "Metadata": {
        "aws:sam:connectors": {
          "getAllItemsFunctionMyConn": {
            "Source": {
              "Type": "AWS::Serverless::Function"
            },
            "Destination": {
              "Type": "AWS::Serverless::SimpleTable"
            }
          }
        }
      },
      "Properties": {
        "PolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Effect": "Allow",
              "Action": [
                "dynamodb:GetItem",
                "dynamodb:Query",
                "dynamodb:Scan",
                "dynamodb:BatchGetItem",
                "dynamodb:ConditionCheckItem",
                "dynamodb:PartiQLSelect"
              ],
              "Resource": [
                {
                  "Fn::GetAtt": [
                    "SampleTable",
                    "Arn"
                  ]
                },
                {
                  "Fn::Sub": [
                    "${DestinationArn}/index/*",
                    {
                      "DestinationArn": {
                        "Fn::GetAtt": [
                          "SampleTable",
                          "Arn"
                        ]
                      }
                    }
                  ]
                }
              ]
            }
          ]
        },
        "Roles": [
          {
            "Ref": "getAllItemsFunctionRole"
          }
        ]
      }
    }
  }
}
```

Utilizzando AWS SAM, si definiscono 23 righe di codice dell'infrastruttura. AWS SAM trasforma il codice nelle oltre 200 righe di CloudFormation codice necessarie per il provisioning dell'applicazione.

## Che cos'è il? AWS SAMCLI
<a name="what-is-sam-cli"></a>

 AWS SAMCLIÈ uno strumento a riga di comando che puoi utilizzare con AWS SAM modelli e integrazioni di terze parti supportate per creare ed eseguire applicazioni serverless. Usa il per: AWS SAMCLI
+ Inizializza rapidamente un nuovo progetto applicativo.
+ Crea la tua applicazione per la distribuzione.
+ Esegui il debug e il test locali.
+ Distribuisci l'applicazione.
+ Configura le pipeline CI/CD di distribuzione.
+ Monitora e risolvi i problemi della tua applicazione nel cloud.
+ Sincronizza le modifiche locali sul cloud durante lo sviluppo.
+ E molto altro ancora\$1

 AWS SAMCLIViene utilizzato al meglio se utilizzato con CloudFormation modelli AWS SAM e. Funziona anche con prodotti di terze parti comeTerraform.

### Inizializza un nuovo progetto
<a name="what-is-sam-cli-init"></a>

Seleziona tra i modelli iniziali o scegli una posizione personalizzata per i modelli per iniziare un nuovo progetto.

Qui, usiamo il **sam init** comando per inizializzare un nuovo progetto applicativo. Selezioniamo il progetto **Hello World Example** per iniziare. AWS SAMCLIScarica un modello iniziale e crea la struttura di directory delle cartelle del nostro progetto. 

![\[Utilizzo sam init per avviare un nuovo progetto applicativo con. AWS SAMCLI\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-01.gif)


Per ulteriori dettagli, consultare [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md).

### Crea la tua applicazione per la distribuzione
<a name="what-is-sam-cli-build"></a>

Package delle dipendenze delle funzioni e organizza il codice del progetto e la struttura delle cartelle per prepararti alla distribuzione.

Qui, utilizziamo il **sam build** comando per preparare la nostra applicazione per la distribuzione. AWS SAMCLICrea una `.aws-sam` directory e organizza le dipendenze delle nostre applicazioni e i file per la distribuzione.

![\[Utilizzo sam build per preparare un'applicazione per la distribuzione.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-02.gif)


Per ulteriori dettagli, consultare [Crea la tua applicazione](serverless-building.md).

### Esegui il debug e il test locali
<a name="what-is-sam-cli-local"></a>

Sul computer locale, simula eventi, test APIs, richiama funzioni e altro ancora per eseguire il debug e testare l'applicazione.

Qui, usiamo il **sam local invoke** comando per richiamare il nostro localmente. `HelloWorldFunction` Per fare ciò, AWS SAMCLI crea un contenitore locale, crea la nostra funzione, la richiama e restituisce i risultati. Puoi usare un'applicazione come Docker per eseguire contenitori sulla tua macchina.

![\[Utilizzo del AWS SAMCLI sam local invoke comando per richiamare localmente una funzione.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-04.gif)


Per ulteriori dettagli, consulta [Testa la tua applicazione](serverless-test-and-debug.md) e [Esegui il debug della tua applicazione](debug-application.md).

### Distribuzione dell'applicazione
<a name="what-is-sam-cli-deploy"></a>

Configura le impostazioni di distribuzione dell'applicazione e distribuiscila nel AWS cloud per fornire le tue risorse.

Qui, utilizziamo il **sam deploy --guided** comando per distribuire la nostra applicazione tramite un flusso interattivo. Ci AWS SAMCLI guida nella configurazione delle impostazioni di distribuzione della nostra applicazione, trasforma il nostro modello in CloudFormation e lo CloudFormation implementa per creare le nostre risorse.

![\[Utilizzo del AWS SAMCLI sam deploy comando per distribuire un'applicazione nel cloud. AWS\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-03.gif)


Per ulteriori dettagli, consultare [Implementa la tua applicazione e le tue risorse](serverless-deploying.md).

### Configura le pipeline CI/CD di distribuzione
<a name="what-is-sam-cli-cicd"></a>

Crea pipeline sicure di *integrazione e distribuzione continue (CI/CD)* utilizzando un sistema supportato. CI/CD 

Qui, utilizziamo il **sam pipeline init --bootstrap** comando per configurare una pipeline di distribuzione CI/CD per la nostra applicazione. Ci AWS SAMCLI guida attraverso le nostre opzioni e genera le AWS risorse e il file di configurazione da utilizzare con il nostro sistema CI/CD.

![\[Utilizzo del AWS SAMCLI sam pipeline init --bootstrap comando per configurare una CI/CD pipeline con il nostro sistema preferito. CI/CD\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-07.gif)


Per ulteriori dettagli, consultare [Implementa con CI/CD sistemi e pipeline](deploying-options.md#serverless-deploying-ci-cd).

### Monitora e risolvi i problemi della tua applicazione nel cloud
<a name="what-is-sam-cli-monitor"></a>

Visualizza informazioni importanti sulle risorse distribuite, raccogli i log e utilizza strumenti di monitoraggio integrati come. AWS X-Ray

Qui, utilizziamo il **sam list** comando per visualizzare le nostre risorse distribuite. Otteniamo il nostro endpoint API e lo invochiamo, il che attiva la nostra funzione. Quindi, utilizziamo **sam logs** per visualizzare i log della nostra funzione.

![\[Utilizzo del AWS SAMCLI sam list comando per ottenere il nostro endpoint API. Quindi, sam logs viene utilizzato per visualizzare i log della nostra funzione.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-08.gif)


Per ulteriori dettagli, consultare [Monitora la tua applicazione](serverless-monitoring.md).

### Sincronizza le modifiche locali sul cloud durante lo sviluppo
<a name="what-is-sam-cli-sync"></a>

Mentre sviluppi sul tuo computer locale, sincronizza automaticamente le modifiche nel cloud. Visualizza rapidamente le modifiche ed esegui test e convalide nel cloud.

Qui, usiamo il **sam sync --watch** comando per AWS SAMCLI controllare le modifiche locali. Modifichiamo il nostro `HelloWorldFunction` codice e rileva AWS SAMCLI automaticamente la modifica e distribuisce i nostri aggiornamenti nel cloud. 

![\[Utilizzo del AWS SAMCLI sam sync comando per sincronizzare le modifiche locali nel AWS Cloud.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-05.gif)


### Prova le risorse supportate nel cloud
<a name="what-is-sam-cli-remote-invoke"></a>

Richiama e trasferisci eventi alle risorse supportate nel cloud.

Qui, utilizziamo il **sam remote invoke** comando per testare una funzione Lambda distribuita nel cloud. Invochiamo la nostra funzione Lambda e ne riceviamo i log e la risposta. Con la nostra funzione Lambda configurata per lo streaming delle risposte, quest' AWS SAMCLIultima invia la risposta in tempo reale.

![\[Utilizzo del AWS SAMCLI sam remote invoke comando per testare la nostra funzione distribuita nel cloud. AWS\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/what-is-sam-09.gif)


## Ulteriori informazioni
<a name="what-is-sam-learn"></a>

Per continuare a saperne di più AWS SAM, consulta le seguenti risorse:
+ **[Il AWS SAM workshop completo](https://s12d.com/sam-ws-en-intro)**: un workshop progettato per insegnarti molte delle principali funzionalità che AWS SAM offre.
+ **[Sessioni con SAM](https://www.youtube.com/playlist?list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd)** — Serie di video creata dal nostro team di AWS Serverless Developer Advocate sull'utilizzo. AWS SAM
+ **[Serverless Land](https://serverlessland.com/)**: sito che riunisce le informazioni, i blog, i video, il codice e le risorse di apprendimento più recenti per la tecnologia serverless. AWS 

## Fasi successive
<a name="what-is-sam-next"></a>

Se è la prima volta che lo usi AWS SAM, vedi. [Guida introduttiva con AWS SAM](serverless-getting-started.md)

# Concetti serverless per AWS Serverless Application Model
<a name="what-is-concepts"></a>

Scopri i concetti base del serverless prima di usare (). AWS Serverless Application Model AWS SAM

## Concetti serverless
<a name="what-is-concepts-terms"></a>

**Architettura basata su eventi**  <a name="what-is-concepts-terms-eda"></a>
Un'applicazione serverless è costituita da singoli AWS servizi, ad esempio AWS Lambda per l'elaborazione e Amazon DynamoDB per la gestione dei database, che svolgono ciascuno un ruolo specializzato. Questi servizi sono quindi liberamente integrati tra loro tramite un'architettura basata sugli eventi. Per ulteriori informazioni sull'architettura basata sugli eventi, vedi [Cos'](https://aws.amazon.com/event-driven-architecture/)è un'architettura basata sugli eventi? . 

**Infrastruttura come codice (IaC)**  <a name="what-is-concepts-terms-iac"></a>
Infrastructure as Code (IaC) è un modo di trattare l'infrastruttura nello stesso modo in cui gli sviluppatori trattano il codice, applicando lo stesso rigore dello sviluppo del codice applicativo al provisioning dell'infrastruttura. Definisci la tua infrastruttura in un file modello, la distribuisci e AWS crea le AWS risorse per te. Con IAc, definisci in codice ciò che desideri AWS fornire. Per un confronto degli strumenti IaC disponibili per AWS, vedere. [Infrastruttura come codice (IaC)](what-is-iac.md)

**Tecnologie serverless**  <a name="what-is-concepts-terms-serverless"></a>
Con le tecnologie AWS serverless, puoi creare ed eseguire applicazioni senza dover gestire i tuoi server. Tutta la gestione dei server viene effettuata da AWS noi e offre numerosi vantaggi, come la scalabilità automatica e l'elevata disponibilità integrata, che consentono di portare rapidamente la propria idea alla produzione. Utilizzando le tecnologie serverless, puoi concentrarti sul core del tuo prodotto senza doverti preoccupare della gestione e del funzionamento dei server. Per ulteriori informazioni sulla tecnologia serverless, consulta quanto segue:  
+ [Serverless attivo AWS](https://aws.amazon.com/serverless/)
+ [Guida per sviluppatori serverless](https://docs.aws.amazon.com/serverless/latest/devguide/serverless-preface.html): fornisce una panoramica concettuale dello sviluppo serverless nel cloud. AWS 
*Per un'introduzione di base ai principali servizi AWS serverless, consulta Serverless [101: Understanding the serverless](https://serverlessland.com/learn/serverless-101) services at Serverless Land.*

**Applicazione serverless**  <a name="what-is-concepts-terms-serverless"></a>
Quando si utilizza AWS SAM, si gestiscono le risorse correlate in un'applicazione, che consiste nel AWS SAM progetto e nel modello. Tutte le risorse dell'applicazione sono definite o a cui si fa riferimento nel AWS SAM modello. Quando AWS SAM elabora il modello, crea CloudFormation risorse. In CloudFormation, le risorse vengono gestite in una singola unità chiamata stack e tutte le risorse in uno stack sono definite dal modello dello stack. CloudFormation 

# Infrastruttura come codice (IaC)
<a name="what-is-iac"></a>

Con Infrastructure as Code (IaC), puoi automatizzare l'implementazione e la gestione delle tue AWS risorse, comprese le applicazioni serverless. IaC consente di definire l'infrastruttura utilizzando il codice, semplificando la versione, la condivisione e la replica delle distribuzioni. Questo approccio ti aiuta a:
+ Accelera il ciclo di sviluppo
+ Semplifica la gestione della configurazione
+ Migliora l'affidabilità e la coerenza delle tue implementazioni

## Strumenti IaC per applicazioni serverless AWS
<a name="iac-tools-aws"></a>

AWS offre diversi strumenti IaC per aiutarti a creare, implementare e gestire le tue risorse cloud. Questa sezione spiega come AWS SAM si inserisce in questo ecosistema e come funziona con altri strumenti AWS IaC.

**AWS CloudFormation**  
Utilizzando [CloudFormation](https://aws.amazon.com/cloudformation/), puoi modellare e fornire l'intera AWS infrastruttura con modelli YAML o JSON. CloudFormation gestisce automaticamente la creazione, gli aggiornamenti e l'eliminazione delle risorse. Quando distribuisci AWS SAM le applicazioni, CloudFormation elabora i modelli trasformati per creare e gestire le tue risorse.

**AWS Serverless Application Model (AWS SAM)**  
AWS SAM consente di creare applicazioni serverless con una sintassi semplificata per la definizione di risorse serverless. È possibile utilizzare AWS SAM modelli per eseguire il provisioning di funzioni Lambda APIs, database e sorgenti di eventi utilizzando una sintassi YAML concisa. AWS SAM trasforma questi modelli in modelli durante la distribuzione. CloudFormation   
Sebbene sia AWS SAM specializzato in applicazioni serverless, puoi utilizzare qualsiasi tipo di CloudFormation risorsa nei tuoi modelli. AWS SAM Ciò offre la flessibilità necessaria per includere risorse non serverless quando necessario.

**AWS Cloud Development Kit (AWS CDK)**  
Con [AWS CDK](https://aws.amazon.com/cdk/), puoi definire la tua infrastruttura serverless utilizzando linguaggi di programmazione familiari come Python TypeScript, Java, C\$1/.Net o Go. È possibile utilizzare costrutti di programmazione come loop e condizioni per definire l'infrastruttura e generare modelli per l'implementazione. AWS CDK CloudFormation È possibile utilizzare il AWS SAMCLI per testare ed eseguire il debug localmente delle applicazioni create con. AWS CDK Per ulteriori informazioni, consulta [Testare localmente le applicazioni CDK](https://docs.aws.amazon.com/cdk/v2/guide/testing-locally.html).

## Confronto degli strumenti IaC per applicazioni serverless
<a name="comparing-iac-tools"></a>

Quando scegli uno strumento IaC per le tue applicazioni serverless, considera le preferenze del tuo team, i requisiti del progetto e i flussi di lavoro esistenti. La tabella seguente confronta le caratteristiche chiave degli strumenti AWS IaC per lo sviluppo senza server:


| **Strumento** | **Uso primario** | **Ideale per** | **Funziona con AWS SAM** | **Quando scegliere** | 
| --- | --- | --- | --- | --- | 
| **CloudFormation** | Gestire AWS un'infrastruttura complessa | Applicazioni che richiedono un controllo dettagliato delle AWS risorse | AWS SAM i modelli si trasformano in CloudFormation modelli durante la distribuzione | Per un controllo granulare delle risorse non serverless | 
| **AWS SAM** | Sviluppo di applicazioni serverless | Team che creano applicazioni serverless utilizzando Lambda | Funzionalità nativa | Quando ci si concentra principalmente su architetture serverless con funzioni Lambda, API Gateway e altre risorse serverless APIs | 
| **AWS CDK** | Definizione dell'infrastruttura utilizzando linguaggi di programmazione | Team che preferiscono i linguaggi tipizzati e un approccio basato sul codice | Genera AWS SAM modelli e usali per i test AWS SAMCLI | Quando è necessaria la definizione di un'infrastruttura programmatica o una logica di configurazione delle risorse complessa | 

**Nota**  
Sebbene questa guida si concentri sugli strumenti IaC AWS nativi, Terraform è un'altra popolare soluzione IaC che può essere utilizzata per definire applicazioni serverless. AWS SAMCLISupporta il test locale delle funzioni Lambda definite in Terraform. Per ulteriori informazioni, consulta [AWS SAMCLITerraformsupporto](terraform-support.md).

## Ulteriori informazioni
<a name="iac-learn-more"></a>
+ Per saperne di più sulle DevOps pratiche su AWS, vedi [Introduzione](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/infrastructure-as-code.html) a on DevOps AWS
+ Per informazioni sull'utilizzo di Lambda con diversi strumenti IAc, consulta Using [Lambda with infrastructure](https://docs.aws.amazon.com/lambda/latest/dg/foundation-iac.html) as code (IaC)