Wie funktioniert AWS SAM

AWS SAM besteht aus zwei Hauptkomponenten, mit denen Sie Ihre serverlose Anwendung erstellen:

Um Ressourcen, Zuordnungen von Ereignisquellen und andere Eigenschaften auszudrücken, die Ihre serverlose Anwendung definieren, definieren Sie Ressourcen und entwickeln Ihre Anwendung in der AWS SAM Vorlage und anderen Dateien in Ihrem Projekt. AWS SAM Sie verwenden den AWS SAM CLI um Befehle in Ihrem AWS SAM Projekt auszuführen. So initialisieren, erstellen, testen und implementieren Sie Ihre serverlose Anwendung.

Was ist die AWS SAM Vorlagenspezifikation?

Die AWS SAM Vorlagenspezifikation ist ein Open-Source-Framework, mit dem Sie Ihren Infrastrukturcode für serverlose Anwendungen definieren und verwalten können. Die AWS SAM Vorlagenspezifikation lautet:

Was ist das AWS SAM Projekt und die AWS SAM Vorlage?

Das AWS SAM Projekt enthält die AWS SAM Vorlage, die die AWS SAM Vorlagenspezifikation enthält. Bei dieser Spezifikation handelt es sich um das Open-Source-Framework, mit dem Sie Ihre serverlose Anwendungsinfrastruktur definieren. Es enthält einige zusätzliche Komponenten AWS, die die Arbeit mit ihnen erleichtern. In diesem Sinne sind AWS SAM Vorlagen eine Erweiterung von AWS CloudFormation Vorlagen.

Hier ist ein Beispiel für eine einfache serverlose Anwendung. Diese Anwendung verarbeitet Anfragen, um alle Elemente aus einer Datenbank über eine HTTP Anfrage abzurufen. Sie besteht aus den folgenden Teilen:

Der Infrastrukturcode dieser Anwendung kann in der folgenden AWS SAM Vorlage definiert werden:

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 Codezeilen ist die folgende Infrastruktur definiert:

Um diese Infrastruktur bereitzustellen, wird die Vorlage auf bereitgestellt AWS CloudFormation. AWS SAM Transformiert während der Bereitstellung die 23 Codezeilen in die AWS CloudFormation Syntax, die für die Generierung dieser Ressourcen erforderlich ist. AWS Die transformierte AWS CloudFormation Vorlage enthält über 200 Codezeilen!

{
  "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"
          }
        ]
      }
    }
  }
}

Mithilfe AWS SAM von definieren Sie 23 Zeilen Infrastrukturcode. AWS SAM wandelt Ihren Code in die mehr als 200 AWS CloudFormation Codezeilen um, die für die Bereitstellung Ihrer Anwendung erforderlich sind.

Was ist der AWS SAM CLI?

Das AWS SAM CLI ist ein Befehlszeilentool, das Sie zusammen mit AWS SAM Vorlagen und unterstützten Integrationen von Drittanbietern verwenden können, um Ihre serverlosen Anwendungen zu erstellen und auszuführen. Verwenden Sie den AWS SAM CLI auf:

Das AWS SAM CLI wird am besten verwendet, wenn es mit AWS SAM AWS CloudFormation Vorlagen verwendet wird. Es funktioniert auch mit Produkten von Drittanbietern wie Terraform.

Initialisieren Sie ein neues Projekt

Wählen Sie aus den Startvorlagen oder wählen Sie einen Speicherort für benutzerdefinierte Vorlagen, um ein neues Projekt zu beginnen.

Hier verwenden wir den sam init Befehl, um ein neues Anwendungsprojekt zu initialisieren. Wir wählen zunächst das Hello World Example-Projekt aus. Das AWS SAM CLI lädt eine Startvorlage herunter und erstellt unsere Projektordner-Verzeichnisstruktur.

Weitere Details finden Sie unter Erstellen Sie Ihre Bewerbung in AWS SAM.

Erstellen Sie Ihre Anwendung für die Bereitstellung

Package Sie Ihre Funktionsabhängigkeiten und organisieren Sie Ihren Projektcode und Ihre Ordnerstruktur, um die Bereitstellung vorzubereiten.

Hier verwenden wir den sam build Befehl, um unsere Anwendung für die Bereitstellung vorzubereiten. Das AWS SAM CLI erstellt ein .aws-sam Verzeichnis und organisiert dort unsere Anwendungsabhängigkeiten und Dateien für die Bereitstellung.

Weitere Details finden Sie unter Erstellen Sie Ihre Anwendung.

Führen Sie lokales Debugging und Testen durch

Simulieren Sie auf Ihrem lokalen Computer Ereignisse, testen SieAPIs, rufen Sie Funktionen auf und vieles mehr, um Ihre Anwendung zu debuggen und zu testen.

Hier verwenden wir den sam local invoke Befehl, um unsere lokal aufzurufen. HelloWorldFunction Um dies zu erreichen, AWS SAM CLI erstellt einen lokalen Container, erstellt unsere Funktion, ruft sie auf und gibt die Ergebnisse aus. Sie können eine Anwendung wie Docker verwenden, um Container auf Ihrem Computer auszuführen.

Weitere Informationen finden Sie unter Testen Sie Ihre Anwendung und Debuggen Sie Ihre Anwendung.

Bereitstellen der Anwendung

Konfigurieren Sie die Bereitstellungseinstellungen Ihrer Anwendung und stellen Sie sie in der AWS Cloud bereit, um Ihre Ressourcen bereitzustellen.

Hier verwenden wir den sam deploy --guided Befehl, um unsere Anwendung über einen interaktiven Ablauf bereitzustellen. Der AWS SAM CLI führt uns durch die Konfiguration der Bereitstellungseinstellungen unserer Anwendung, wandelt unsere Vorlage um und stellt sie bereit AWS CloudFormation, um unsere Ressourcen AWS CloudFormation zu erstellen.

Weitere Details finden Sie unter Stellen Sie Ihre Anwendung und Ressourcen bereit.

Konfigurieren Sie CI/CD-Bereitstellungspipelines

Erstellen Sie sichere CI/CD-Pipelines (Continuous Integration and Delivery) mithilfe eines unterstützten CI/CD-Systems.

Hier verwenden wir den sam pipeline init --bootstrap Befehl, um eine CI/CD-Bereitstellungspipeline für unsere Anwendung zu konfigurieren. Der AWS SAM CLI führt uns durch unsere Optionen und generiert die AWS Ressourcen und die Konfigurationsdatei zur Verwendung mit unserem CI/CD-System.

Weitere Details finden Sie unter Stellen Sie die Lösung mit CI/CD-Systemen und -Pipelines bereit.

Überwachen Sie Ihre Anwendung in der Cloud und beheben Sie Fehler

Sehen Sie sich wichtige Informationen über Ihre bereitgestellten Ressourcen an, sammeln Sie Protokolle und nutzen Sie integrierte Überwachungstools wie AWS X-Ray.

Hier verwenden wir den sam list Befehl, um unsere bereitgestellten Ressourcen einzusehen. Wir rufen unseren API Endpunkt ab und rufen ihn auf, was unsere Funktion auslöst. Dann sehen wir uns sam logs die Protokolle unserer Funktion an.

Weitere Details finden Sie unter Überwachen Sie Ihre Anwendung.

Synchronisieren Sie lokale Änderungen während der Entwicklung mit der Cloud

Synchronisieren Sie während der Entwicklung auf Ihrem lokalen Computer automatisch Änderungen mit der Cloud. Sehen Sie sich Ihre Änderungen schnell an und führen Sie Tests und Validierungen in der Cloud durch.

Hier verwenden wir den sam sync --watch Befehl, um AWS SAM CLI achten Sie auf lokale Änderungen. Wir modifizieren unseren HelloWorldFunction Code und AWS SAM CLI erkennt die Änderung automatisch und stellt unsere Updates in der Cloud bereit.

Testen Sie unterstützte Ressourcen in der Cloud

Rufen Sie Ereignisse auf und leiten Sie sie an unterstützte Ressourcen in der Cloud weiter.

Hier verwenden wir den sam remote invoke Befehl, um eine bereitgestellte Lambda-Funktion in der Cloud zu testen. Wir rufen unsere Lambda-Funktion auf und erhalten ihre Protokolle und Antworten. Mit unserer Lambda-Funktion, die für das Streamen von Antworten konfiguriert ist, AWS SAM CLI streamt seine Antwort in Echtzeit zurück.

Weitere Informationen

Weitere Informationen AWS SAM dazu finden Sie in den folgenden Ressourcen:

Nächste Schritte

Wenn Sie es zum ersten Mal verwenden AWS SAM, finden Sie weitere Informationen unter. Erste Schritte mit AWS SAM