Serverless Application Model (SAM) in AWS - Step-by-Step Execution

Process Flow - Serverless Application Model (SAM)

Write SAM Template

↓

Run sam build

↓

Run sam deploy

↓

AWS CloudFormation Creates Resources

↓

Serverless App is Live

↓

Invoke Functions / Use API Gateway

↓

Monitor and Update

↩Back to Write SAM Template

The flow shows writing a SAM template, building, deploying, AWS creating resources, app running, and monitoring with updates.

Execution Sample

AWS

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Handler: app.lambda_handler
      Runtime: python3.12
      Events:
        HelloWorld:
          Type: Api
          Properties:
            Path: /hello
            Method: GET

This SAM template defines a simple Lambda function triggered by an HTTP GET request at /hello.

Process Table

Step	Action	Input/State	Output/State Change
1	Write SAM Template	Empty project	SAM template with Lambda function and API event defined
2	Run sam build	SAM template	Build artifacts prepared for deployment
3	Run sam deploy	Build artifacts	CloudFormation stack created or updated
4	CloudFormation creates resources	Stack request	Lambda function, API Gateway, IAM roles created
5	Serverless app is live	Resources ready	API endpoint available, Lambda ready to invoke
6	Invoke function via API	HTTP GET /hello	Lambda function executes and returns response
7	Monitor and update	Logs and metrics	Template updated and redeployed as needed
8	Exit	No further changes	Application running and serving requests

💡 Execution stops when the serverless application is deployed and running, ready to serve requests.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
SAM Template	None	Defined with function and API	Unchanged	Used for deployment	Used by CloudFormation	Deployed	Deployed and live
Build Artifacts	None	None	Created	Used for deployment	Unchanged	Unchanged	Unchanged
CloudFormation Stack	None	None	None	Created/Updated	Resources created	Resources ready	Resources ready
Lambda Function	None	None	None	None	Created	Ready to invoke	Ready to invoke
API Gateway	None	None	None	None	Created	Endpoint available	Endpoint available

Key Moments - 3 Insights

Why do we need to run 'sam build' before 'sam deploy'?

'sam build' prepares your code and dependencies into a deployable package. Without it, 'sam deploy' won't have the correct artifacts to create resources, as shown in execution_table step 2 and 3.

What happens if the SAM template is missing the 'Transform' section?

CloudFormation won't recognize SAM-specific resources like AWS::Serverless::Function, so deployment fails. This is implied in execution_table step 3 where the template is used for deployment.

How does the API Gateway connect to the Lambda function?

In the SAM template, the 'Events' section links the API path and method to the Lambda function. CloudFormation creates this connection during resource creation (step 4).

Visual Quiz - 3 Questions

Look at the execution_table, at which step does AWS create the Lambda function and API Gateway?

A Step 4

B Step 2

C Step 6

D Step 3

💡 Hint

Refer to execution_table row with 'CloudFormation creates resources' which is step 4.

According to variable_tracker, what is the state of the SAM Template after step 3?

A Not yet defined

B Deployed and live

C Used for deployment

D Created by CloudFormation

💡 Hint

Check the 'SAM Template' row under 'After Step 3' column in variable_tracker.

If you skip 'sam build' and run 'sam deploy' directly, what will likely happen?

A CloudFormation stack is created but resources are missing

B Deployment fails due to missing build artifacts

C Deployment succeeds with no issues

D Lambda function runs without API Gateway

💡 Hint

Refer to key_moments about the importance of 'sam build' before 'sam deploy'.

Concept Snapshot

AWS SAM is a template specification to define serverless apps.
Write a SAM template with Lambda and events.
Run 'sam build' to prepare deployment artifacts.
Run 'sam deploy' to create/update resources via CloudFormation.
App runs with Lambda and API Gateway connected.
Update template and redeploy to change app.

Full Transcript

The Serverless Application Model (SAM) lets you define serverless apps using a simple template. You write a SAM template describing Lambda functions and their triggers like API Gateway. Then you run 'sam build' to package your code and dependencies. Next, 'sam deploy' uses AWS CloudFormation to create or update your resources. Once deployed, your Lambda functions and API Gateway endpoints are live and ready to serve requests. You can monitor logs and metrics, then update your SAM template and redeploy to improve or fix your app. This flow helps you manage serverless apps easily and repeatably.