Difference between SAM template and Cloudformation template

Amazon Web-ServicesAws LambdaAmazon CloudformationServerless Framework

Amazon Web-Services Problem Overview

I'm finding it hard to understand the difference between SAM template and Cloudformation template. I know that SAM template can be used to define Serverless Applications like Lambda, but how does that make it different from Cloudformation template? Is the syntax different? I can still specify the Lambda definitions in cloudformation template. So, my question is why should I care about SAM? Won't knowing about just cloud formation template be sufficient?

Amazon Web-Services Solutions

Solution 1 - Amazon Web-Services

From CloudFormation's perspective, SAM is a transform. Meaning: SAM templates are syntactically equivalent, but they allow you to define your serverless app with more brevity. The SAM template eventually gets expanded into full CFN behind the scenes. If you already know CFN, but want to write less YAML code, SAM may be beneficial to you. The idea is to reduce your effort.

Solution 2 - Amazon Web-Services

SAM templates are a superset of Cloudformation. Any Cloudformation template can be run through SAM unchanged, and it will work. SAM supports all the types available in Cloudformation templates, so you can think of SAM as "CloudFormation++".

However, SAM also gives you additional "transforms" that allow you to define certain concepts succinctly, and SAM will figure out what you mean and fill in the the missing pieces to create a full, expanded, legal Cloudformation template.

Example: For SAM (and Serverless Framework) users, who deal mostly in Lambda functions, one of the more most useful transforms is the Events property on the Lambda function -- SAM will add all the objects needs to access that function through an API path in API Gateway.

    Type: AWS::Serverless::Function
      CodeUri: HelloWorldFunction
      Handler: app.lambdaHandler
      Runtime: nodejs12.x
      Events:  # <--- "Events" property is not a real Cloudformation Lambda property
          Type: Api
            Path: /hello
            Method: get

The SAM template snippet shown above gets transformed/expanded into several API Gateway objects (a RestApi, a deployment, and a stage). The AWS::Serverless::Function type used in this snippet is not a real Cloudformation type -- you won't find it in the docs. SAM expands it into a Cloudformation template containing a AWS::Lambda::Function object and several different AWS::ApiGateway::* objects that Cloudformation understands.

To give you an idea of how much manual coding this saves you, here's what the expanded version of the above SAM template looks like as a full Cloudformation template:

    Type: AWS::Lambda::Permission
      Action: lambda:InvokeFunction
      Principal: apigateway.amazonaws.com
        Ref: HelloWorldFunction
        - arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${__ApiId__}/${__Stage__}/GET/hello
        - __Stage__: "*"
            Ref: ServerlessRestApi

    Type: AWS::IAM::Role
        Version: '2012-10-17'
        - Action:
          - sts:AssumeRole
          Effect: Allow
            - lambda.amazonaws.com
      - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      - Value: SAM
        Key: lambda:createdBy

    Type: AWS::ApiGateway::Stage
        Ref: ServerlessRestApiDeployment_NNN
        Ref: ServerlessRestApi
      StageName: Prod

    Type: AWS::ApiGateway::Deployment
        Ref: ServerlessRestApi
      Description: 'RestApi deployment id: ???'
      StageName: Stage

    Type: AWS::ApiGateway::RestApi
          version: '1.0'
            Ref: AWS::StackName
                httpMethod: POST
                type: aws_proxy
                  Fn::Sub: arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${HelloWorldFunction.Arn}/invocations
              responses: {}
        swagger: '2.0'

    Type: AWS::Lambda::Function
        S3Bucket: aws-sam-cli-managed-default-samclisourcebucket-???
        S3Key: temp/???
      - Value: SAM
        Key: lambda:createdBy
      Handler: app.lambdaHandler
        - HelloWorldFunctionRole
        - Arn
      Timeout: 3
      Runtime: nodejs12.x

Previously, if you were authoring pure Cloudformation, you would have had to code all this by hand, over and over, for each API Gateway endpoint that you wanted to create. Now, with a SAM template, you define the API as an "Event" property of the Lambda function, and SAM (or Serverless Framework) takes care of the drudgery.

In the old days, when we had to do all this by hand, it totally sucked. But now, everything is glorious again.

Solution 3 - Amazon Web-Services

Like @Luis Colon said, SAM is a transform. What that means, is that at the top of a SAM Template there is a Transform statement that lets CloudFormation know to run an intrinsic function, Transform, on this SAM template to turn it into a CloudFormation template. So, all SAM Templates will eventually be converted into CF templates, but for the end-user in most cases it is easier to just use the SAM template. For instance, for a simple application with Lambdas triggered by a new API you're creating, the SAM template will let you accomplish this in fewer lines than CloudFormation.

To extend this, the Serverless Framework behaves similarly. Serverless is designed to work across platforms (AWS, Azure, etc.). It's syntax looks very similar to SAM, and it too converts the template into the target platform's (ie. AWS) fuller version of the template (ie. CloudFormation template).

Solution 4 - Amazon Web-Services

You can imagine SAM as an extended form of CloudFormation. SAM makes Serverless/Lambda deployments easier.
Even CloudFormation can deploy lambda scripts using inline scripts but it has a limitation of 4096 characters and you cannot pack custom dependencies, python libraries.

So to make Lambda/Serverless deployments easy SAM is used. SAM is a CLI tool. You cannot find SAM in AWS Console.
In case of python deployment, sam will read the requirements.txt file build a package, and will deploy the package when you wish to sam deploy
So at the end of the day you can write as much lengthy Lambda Code, use as many libraries you want and even import your custom libraries i.e. complete flexibility.


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionSchleirView Question on Stackoverflow
Solution 1 - Amazon Web-ServicesLuis ColonView Answer on Stackoverflow
Solution 2 - Amazon Web-ServicesPatrick ChuView Answer on Stackoverflow
Solution 3 - Amazon Web-ServicesdalumillerView Answer on Stackoverflow
Solution 4 - Amazon Web-ServicesShivam AnandView Answer on Stackoverflow