In che modo AWS SAM funzionamento - AWS Serverless Application Model
Che cos'è il AWS SAM specificazione del modello?Che cos'è il AWS SAM progetto e AWS SAM modello?Che cos'è il AWS SAM CLI?Ulteriori informazioniPassaggi successivi

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

In che modo AWS SAM funzionamento

AWS SAM è costituito da due componenti principali utilizzati per creare un'applicazione serverless:

  1. Il AWS SAM project— Le cartelle e i file che vengono creati quando si esegue il sam init comando. Questa directory include AWS SAM modello, un file importante che definisce il AWS risorse. Questo modello include AWS SAM specifica del modello: il framework open source dotato di una sintassi abbreviata semplificata che consente di definire le funzioni, gli eventiAPIs, le configurazioni e le autorizzazioni dell'applicazione serverless.

  2. La AWS SAMCLI— Uno strumento da riga di comando che puoi usare con AWS SAM progetta e supporta integrazioni di terze parti per creare ed eseguire applicazioni serverless. Il AWS SAM CLI è lo strumento che usi per eseguire comandi sul tuo AWS SAM progetta e alla fine trasformalo nella tua applicazione serverless.

Per esprimere risorse, mappature delle sorgenti degli eventi e altre proprietà che definiscono l'applicazione serverless, si definiscono le risorse e si sviluppa l'applicazione in AWS SAM modello e altri file presenti nel AWS SAM progetto. Usi il AWS SAM CLI per eseguire comandi sul tuo AWS SAM project, ovvero il modo in cui inizializzate, create, testate e distribuite la vostra applicazione serverless.

Sei nuovo nel mondo serverless?

Ti consigliamo di recensireConcetti serverless per AWS Serverless Application Model.

Che cos'è il AWS SAM specificazione del modello?

Il AWS SAM la specifica del modello è un framework open source che è possibile utilizzare per definire e gestire il codice dell'infrastruttura applicativa serverless. Il AWS SAM la specifica del modello è:

  • Costruito su AWS CloudFormation— Usi il AWS CloudFormation sintassi direttamente nel tuo AWS SAM modello, sfruttando il suo ampio supporto per le configurazioni di risorse e proprietà. Se hai già familiarità con AWS CloudFormation, non è necessario imparare a usare un nuovo servizio per gestire il codice dell'infrastruttura applicativa.

  • Un'estensione di AWS CloudFormation – AWS SAM offre una sintassi unica che si concentra specificamente sull'accelerazione dello sviluppo senza server. È possibile utilizzare entrambi i AWS CloudFormation e AWS SAM sintassi all'interno dello stesso modello.

  • Una sintassi astratta e abbreviata: utilizzo di 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 svolge il complesso lavoro di trasformazione del modello nel codice necessario per fornire l'infrastruttura tramite AWS CloudFormation.

Che cos'è il AWS SAM progetto e AWS SAM modello?

Il AWS SAM il progetto include AWS SAM modello che contiene il AWS SAM specificazione del modello. Questa specifica è il framework open source utilizzato per definire l'infrastruttura applicativa serverless su AWS, con alcuni componenti aggiuntivi che li rendono più facili da usare. In questo senso, AWS SAM i modelli sono un'estensione di AWS 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 HTTP richiesta. Consiste delle seguenti parti:

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

  2. E HTTP API per fungere da comunicazione tra il client (richiedente) e l'applicazione.

  3. Un database per memorizzare gli oggetti.

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

Architettura applicativa di una semplice applicazione serverless.

Il codice di infrastruttura di questa applicazione può essere definito nel modo 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: nodejs12.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, è definita la seguente infrastruttura:

  • Una funzione che utilizza il AWS Lambda servizio.

  • E HTTP API utilizzando il servizio Amazon API Gateway.

  • Un database che utilizza il servizio Amazon DynamoDB.

  • Il AWS Identity and Access Management (IAM) autorizzazioni necessarie per consentire a questi servizi di interagire tra loro.

Per fornire questa infrastruttura, il modello viene distribuito su AWS CloudFormation. Durante il dispiegamento, AWS SAM trasforma le 23 righe di codice in AWS CloudFormation sintassi richiesta per generare queste risorse in AWS. I trasformati AWS CloudFormation il modello contiene oltre 200 righe di codice!

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "getAllItemsFunction": {
      "Type": "AWS::Lambda::Function",
      "Metadata": {
        "SamResourceId": "getAllItemsFunction"
      },
      "Properties": {
        "Code": {
          "S3Bucket": "aws-sam-cli-managed-default-samclisourcebucket-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"
          }
        ]
      }
    }
  }
}

Usando AWS SAM, si definiscono 23 righe di codice dell'infrastruttura. AWS SAM trasforma il tuo codice nelle oltre 200 righe di AWS CloudFormation codice necessario per fornire l'applicazione.

Che cos'è il AWS SAM CLI?

Il AWS SAM CLI è uno strumento da riga di comando che è possibile utilizzare con AWS SAM modelli e integrazioni di terze parti supportate per creare ed eseguire applicazioni serverless. Usa il AWS SAM CLI to:

  • 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 di distribuzione CI/CD.

  • Monitora e risolvi i problemi della tua applicazione nel cloud.

  • Sincronizza le modifiche locali sul cloud durante lo sviluppo.

  • E molto altro ancora!

Il AWS SAM CLI è meglio utilizzato se usato con AWS SAM e AWS CloudFormation modelli. Funziona anche con prodotti di terze parti come Terraform.

Inizializza un nuovo progetto

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. Il AWS SAM CLI scarica 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 SAM CLI.

Per ulteriori dettagli, consulta Crea la tua candidatura in AWS SAM.

Crea la tua applicazione per la distribuzione

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. Il AWS SAM CLI crea una .aws-sam directory e vi organizza le dipendenze e i file dell'applicazione per la distribuzione.

Utilizzo sam build per preparare un'applicazione per la distribuzione.

Per ulteriori dettagli, consulta Crea la tua applicazione.

Esegui il debug e il test locali

Sul computer locale, simula eventi, testAPIs, 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ò, il AWS SAM CLI 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 di AWS SAM CLI sam local invokecomando per richiamare localmente una funzione.

Per ulteriori dettagli, consulta Testa la tua applicazione e Esegui il debug della tua applicazione.

Distribuzione dell'applicazione

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

Qui, utilizziamo il sam deploy --guided comando per distribuire la nostra applicazione tramite un flusso interattivo. Il AWS SAM CLI ci guida nella configurazione delle impostazioni di distribuzione della nostra applicazione, trasforma il nostro modello in AWS CloudFormation e si distribuisce su AWS CloudFormation per creare le nostre risorse.

Utilizzo di AWS SAM CLI sam deploycomando per distribuire un'applicazione su AWS Cloud.

Per ulteriori dettagli, consulta Implementa la tua applicazione e le tue risorse.

Configura le pipeline di distribuzione CI/CD

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

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

Utilizzo di AWS SAM CLI sam pipeline init --bootstrapcomando per configurare una pipeline CI/CD con il nostro sistema CI/CD preferito.

Per ulteriori dettagli, consulta Implementa con sistemi e pipeline CI/CD.

Monitora e risolvi i problemi della tua applicazione nel cloud

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 API endpoint e lo invochiamo, il che attiva la nostra funzione. Quindi, utilizziamo sam logs per visualizzare i log della nostra funzione.

Utilizzo di AWS SAM CLI sam listcomando per ottenere il nostro API endpoint. Quindi, sam logs viene utilizzato per visualizzare i log della nostra funzione.

Per ulteriori dettagli, consulta Monitora la tua applicazione.

Sincronizza le modifiche locali sul cloud durante lo sviluppo

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 avere AWS SAM CLI presta attenzione ai cambiamenti locali. Modifichiamo il nostro HelloWorldFunction codice e il AWS SAM CLI rileva automaticamente la modifica e distribuisce i nostri aggiornamenti nel cloud.

Utilizzo di AWS SAM CLI sam synccomando per sincronizzare le modifiche locali con AWS Cloud.

Testa le risorse supportate nel cloud

Richiama e passa 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, AWS SAM CLI trasmette la sua risposta in tempo reale.

Utilizzo di AWS SAM CLI sam remote invokecomando per testare la nostra funzione distribuita nel AWS Cloud.

Ulteriori informazioni

Per continuare a conoscere AWS SAM, consulta le seguenti risorse:

  • Il completo AWS SAM Workshop : un workshop progettato per insegnarti molte delle principali funzionalità che AWS SAM fornisce.

  • Sessioni con SAM — Serie di video creata dal nostro AWS Il team di Serverless Developer Advocate sull'utilizzo AWS SAM.

  • Serverless Land: sito che riunisce le informazioni, i blog, i video, il codice e le risorse di apprendimento più recenti per AWS senza server.

Passaggi successivi

Se è la prima volta che lo usi AWS SAM, consulta Guida introduttiva con AWS SAM.