Come funziona AWS SAM

AWS SAM è costituito da due componenti principali utilizzati per creare 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 Si utilizza il AWS SAM CLI per eseguire comandi sul AWS SAM progetto, ovvero inizializzare, creare, testare e distribuire l'applicazione serverless.

Quali sono le specifiche del AWS SAM modello?

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 è:

Cosa sono il AWS SAM progetto e il modello? AWS SAM

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 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:

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:

Per fornire questa infrastruttura, il modello viene distribuito su. AWS CloudFormation Durante la distribuzione, AWS SAM trasforma le 23 righe di codice nella AWS CloudFormation sintassi richiesta per generare queste risorse. AWS Il AWS CloudFormation modello trasformato 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"
          }
        ]
      }
    }
  }
}

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

Che cos'è il AWS SAM CLI?

La AWS SAM CLI è 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 AWS SAM CLI to:

La AWS SAM CLI viene utilizzato al meglio se utilizzato con AWS CloudFormation modelli AWS SAM e. 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 nostra struttura di cartelle di progetto.

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 delle applicazioni 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.

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 nel 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 lo AWS CloudFormation implementa per creare le nostre risorse.

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. La AWS SAM CLI ci guida attraverso le nostre opzioni e genera AWS le risorse e il file di configurazione da utilizzare con il nostro sistema CI/CD.

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.

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

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

Ulteriori informazioni

Per continuare a saperne di più AWS SAM, consulta le seguenti risorse:

Passaggi successivi

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