Serverless architecture has seen some fast development in recent years. AWS serverless ecosystem supports that development by providing services like AWS Serverless Application Model (SAM). This service will be perfect for those who want to focus only on the functionality of the application. The topics that we discuss in this blog include:
Check out our full AWS course in this Video:
What is AWS SAM?
AWS SAM was launched to make the process of building serverless applications simpler and easier. AWS SAM was licensed under the open-source framework so anyone can contribute to its development. The code for the whole serverless application is maintained in a repository structure. This helps in creating development patterns.
Code duplication and code complexity are the topmost problems that developers using the AWS SAM framework should not be worried about. This makes them focus on creating better applications with neat and organized code.
There are two components of the AWS SAM framework:
- SAM Templates
- SAM Command Line Interface (CLI)
AWS SAM Templates
By using YAML, developers can build serverless applications that are backed up by AWS SAM templates. Since it provides shorthand syntax for APIs, functions, and even databases, the developers can complete complex features with just a few lines of code.
AWS SAM CLI
The purpose of AWS SAM CLI is to allow developers to get started with the development and deployment of SAM-based applications. With some similarities to the Lambda environment, SAM CLI provides an environment that allows users to develop, test, and debug applications.
These processes are all done locally and these applications are defined by SAM templates or AWS CDK. AWS SAM has the ability to deploy the built applications to AWS; AWS SAM also has the ability to create CI/CD pipelines. AWS SAM and its CLI are licensed under the Apache 2.0 license.
Benefits of AWS SAM:
Now that you know what AWS SAM is, let us take a look at its benefits.
Single-deployment Configuration
To operate under a single CloudFormation stack, AWS SAM makes all similar components and resources like a pack of one. Then the components and resources under the stack are deployed as a single-version entity. This deployed entity has a configuration that has been shared with all resources. This makes sure that all related resources are deployed at once.
AWS SAM was basically an AWS CloudFormation extension. SAM makes use of various available features in AWS CloudFormation including a full resource suite, intrinsic functions, etc. AWS CloudFormation resources and AWS SAM resources can both be available in the resources section of AWS SAM templates.
When comparing AWS SAM to CloudFormation for constructing serverless apps, AWS SAM wins because both resources are available, making it more concise and less configurable.
Local Debugging and Testing
You would have read earlier that the CLI gives a local execution environment like Lambda. With the help of this environment, the application built using SAM templates can do local testing and debugging. This helps the developers to experience the Lambda environment on their local systems and provides assurance that the application will run on the cloud without any discrepancies.
Testing the application locally reduces the testing and debugging cost in the cloud. There are multiple toolkits available for different IDEs that are provided by AWS. By using these toolkits, it is possible to find the issues that the developers may face in the cloud, and you can troubleshoot them before deploying the application.
AWS SAM can be combined with other AWS services and tools that make the process of developing serverless applications easier. AWS serverless application repository contains all new applications. To code, test the desired application, we can make use of AWS Cloud9 IDE. For continuous integration and deployment, we can make use of CodeBuild, CodeDeploy, and CodePipeline.
Get 100% Hike!
Master Most in Demand Skills Now!
Building a Serverless Application with AWS SAM
Since you are now familiar with AWS SAM, we can see how to build a serverless application using this service.
Installing SAM CLI:
To create an application on your local machine, SAM CLI should be installed. To install CLI in Linux, use the following command:
$ brew tap aws/tap
$ brew install aws-sam-cli
Download a Sample AWS SAM Application
After installing SAM CLI, you can download the basic SAM template, which is for the default application. To initiate the process, use the following command:
sam init
Once the process is initiated, follow the steps and enter the below-mentioned details:
- Name of the application
- Runtime
- Dependency
- Template
Once this process is done, AWS SAM will automatically generate the directory and code for the application and a .yaml file, by default—template. YAML. This will be based on the runtime you selected.
Building the Application
The next step is to build the application. To do that, run the following command in the directory where the YAML file is stored:
sam build
Once the process is successfully completed, it will create an output like the image below:
After that, SAM CLI will take care of converting the SAM template to CloudFormation syntaxes. It also builds the dependencies and places the code under the build directory.
Deploying the Application to AWS Lambda
Now, let us see how we can deploy the application into the cloud. For that, you have to convert the whole code to a zip file and upload it to Amazon S3. From there, the AWS Lambda service will automatically execute the code by downloading it. To deploy the application, use the following command:
sam deploy --guided
After executing the command, the terminal will prompt multiple questions. You can either answer them or just leave them as default.
Then through the API gateway, it will show the https endpoint that can be used for testing the application. To know that you are at the endpoint, you can look for the JSON response that will look like:
{"message": "hello world"}
Test the Application Locally
Now, let us see how we can run and test the application. AWS SAM gives us a couple of commands that will run the serverless application. To run the application, use the following command:
sam local start-api
This command will simulate the REST API by starting a new local endpoint. It downloads the container in which you can execute your function locally. The final result would be the same as the application in the cloud. To test your application, you just need to install the Docker setup. Once the application is running locally, you can use the Curl command to test it.
curl http://127.0.0.1:3000/hello
Conclusion
I hope this blog gives you insight into what AWS SAM is all about. To conclude, AWS SAM is a widely used framework for automating the deployment of a serverless application.