Wie funktioniert AWS SAM - AWS Serverless Application Model
Was ist die AWS SAM Vorlagenspezifikation?Was ist das AWS SAM Projekt und die AWS SAM Vorlage?Was ist das? AWS SAMCLIWeitere InformationenNächste Schritte

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Wie funktioniert AWS SAM

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

  1. Das AWS SAM Projekt— Die Ordner und Dateien, die erstellt werden, wenn Sie den sam init Befehl ausführen. Dieses Verzeichnis enthält die AWS SAM Vorlage, eine wichtige Datei, die Ihre AWS Ressourcen definiert. Diese Vorlage enthält die AWS SAM Vorlagenspezifikation — das Open-Source-Framework mit einer vereinfachten Kurzsyntax, mit der Sie die Funktionen, Ereignisse, APIs, Konfigurationen und Berechtigungen Ihrer serverlosen Anwendung definieren.

  2. Die AWS SAMCLI— Ein Befehlszeilentool, das Sie mit Ihrem AWS SAM Projekt und unterstützten Integrationen von Drittanbietern verwenden können, um Ihre serverlosen Anwendungen zu erstellen und auszuführen. Das AWS SAMCLI) ist das Tool, mit dem Sie Befehle für Ihr AWS SAM Projekt ausführen und es schließlich in Ihre serverlose Anwendung umwandeln.

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 die AWS SAMCLI, um Befehle in Ihrem AWS SAM Projekt auszuführen. Auf diese Weise initialisieren, erstellen, testen und implementieren Sie Ihre serverlose Anwendung.

Sind Sie neu im Bereich Serverless?

Wir empfehlen Ihnen, es zu überprüfenServerlose Konzepte für AWS Serverless Application Model.

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:

  • Darauf AWS CloudFormation aufbauend — Sie verwenden die AWS CloudFormation Syntax direkt in Ihrer AWS SAM Vorlage und profitieren dabei von der umfassenden Unterstützung von Ressourcen- und Eigenschaftenkonfigurationen. Wenn Sie bereits damit vertraut sind AWS CloudFormation, müssen Sie sich nicht erst mit einem neuen Service vertraut machen, um Ihren Anwendungsinfrastrukturcode zu verwalten.

  • Eine Erweiterung von AWS CloudFormation — AWS SAM bietet eine eigene, einzigartige Syntax, die sich speziell auf die Beschleunigung der serverlosen Entwicklung konzentriert. Sie können sowohl die AWS SAM Syntax als AWS CloudFormation auch innerhalb derselben Vorlage verwenden.

  • Eine abstrakte, kurze Syntax — Mithilfe der AWS SAM Syntax können Sie Ihre Infrastruktur schnell, mit weniger Codezeilen und mit einer geringeren Fehlerwahrscheinlichkeit definieren. Die Syntax wurde speziell entwickelt, um die Komplexität bei der Definition Ihrer serverlosen Anwendungsinfrastruktur zu verringern.

  • Transformativ — AWS SAM übernimmt die komplexe Aufgabe, Ihre Vorlage in den Code umzuwandeln, der für die Bereitstellung Ihrer Infrastruktur erforderlich ist. AWS CloudFormation

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:

  1. Eine Funktion, die die Logik zur Verarbeitung der Anfrage enthält.

  2. Eine HTTP-API, die als Kommunikation zwischen dem Client (Anforderer) und der Anwendung dient.

  3. Eine Datenbank zum Speichern von Elementen.

  4. Berechtigungen für die sichere Ausführung der Anwendung.

Anwendungsarchitektur einer einfachen serverlosen Anwendung.

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

  • Eine Funktion, die den AWS Lambda Dienst verwendet.

  • Eine HTTP-API, die den Amazon API Gateway Gateway-Service verwendet.

  • Eine Datenbank, die den Amazon DynamoDB-Service verwendet.

  • Die AWS Identity and Access Management (IAM-) Berechtigungen, die erforderlich sind, damit diese Dienste miteinander interagieren können.

Um diese Infrastruktur bereitzustellen, wird die Vorlage auf AWS CloudFormation bereitgestellt. 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 das? AWS SAMCLI

Das AWS SAMCLI 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 das, um AWS SAMCLI:

  • Initialisieren Sie schnell ein neues Anwendungsprojekt.

  • Erstellen Sie Ihre Anwendung für die Bereitstellung.

  • Führen Sie lokales Debugging und Testen durch.

  • Stellen Sie die Anwendung bereit.

  • Konfigurieren Sie CI/CD-Bereitstellungspipelines.

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

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

  • Und mehr!

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

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 SAMCLI lädt eine Startvorlage herunter und erstellt unsere Projektordner-Verzeichnisstruktur.

Wird verwendetsam init, um ein neues Anwendungsprojekt mit dem zu starten AWS SAMCLI.

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 SAMCLI erstellt ein .aws-sam Verzeichnis und organisiert dort unsere Anwendungsabhängigkeiten und Dateien für die Bereitstellung.

Wird verwendetsam build, um eine Anwendung für die Bereitstellung vorzubereiten.

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 Sie APIs, 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 SAMCLI erstellt der 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.

Verwenden Sie den AWS SAMCLI sam local invoke Befehl, um eine Funktion lokal aufzurufen.

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. Er AWS SAMCLI führt uns durch die Konfiguration der Bereitstellungseinstellungen unserer Anwendung, wandelt unsere Vorlage in Ressourcen um und stellt sie bereit AWS CloudFormation, um unsere AWS CloudFormation Ressourcen zu erstellen.

Den AWS SAMCLI sam deploy Befehl verwenden, um eine Anwendung in der AWS Cloud bereitzustellen.

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 SAMCLI führt uns durch unsere Optionen und generiert die AWS Ressourcen und die Konfigurationsdatei für unser CI/CD-System.

Verwenden des AWS SAMCLI sam pipeline init --bootstrap Befehls zur Konfiguration einer CI/CD-Pipeline mit unserem bevorzugten 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.

Verwenden Sie den AWS SAMCLI sam list Befehl, um unseren API-Endpunkt abzurufen. sam logsWird dann verwendet, um die Protokolle unserer Funktion anzuzeigen.

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 nach lokalen Änderungen AWS SAMCLI Ausschau zu halten. Wir ändern unseren HelloWorldFunction Code und erkennen die Änderung AWS SAMCLI automatisch und stellen unsere Updates in der Cloud bereit.

Verwenden Sie den AWS SAMCLI sam sync Befehl, um lokale Änderungen mit der AWS Cloud zu synchronisieren.

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. Da unsere Lambda-Funktion so konfiguriert ist, dass sie Antworten streamt, AWS SAMCLI streamt sie ihre Antwort in Echtzeit zurück.

Verwenden Sie den AWS SAMCLI sam remote invoke Befehl, um unsere bereitgestellte Funktion in der AWS Cloud zu testen.

Weitere Informationen

Weitere Informationen AWS SAM finden Sie in den folgenden Ressourcen:

  • Der komplette AWS SAM Workshop — Ein Workshop, in dem Sie viele der wichtigsten Funktionen des Workshops kennenlernen AWS SAM möchten.

  • Sessions with SAM — Videoserie, die von unserem AWS Serverless Developer Advocate-Team zur Verwendung AWS SAM erstellt wurde.

  • Serverless Land — Website, die die neuesten Informationen, Blogs, Videos, Code und Lernressourcen für AWS Serverless zusammenfasst.

Nächste Schritte

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