Search for a command to run...
I am a Lead Engineer from India. Love to blog about serverless and help teams design and develop serverless architecture. An AWS cloud practitioner. Blogs about AWS Services utilising AWS CDK, CloudFormation, Terraform.
No comments yet. Be the first to comment.
Transformers, the backbone of many state-of-the-art NLP models such as BERT, GPT has revolutionized the way we approach natural language understanding tasks. One key innovation in transformers is their ability to handle entire sequences of tokens sim...
When an User prompts the questions to the LLM, it produces the response based on the training data. The pre-trained LLM data is its parametric data. It might not have an context specific to our query. LLM still produces an answer confidently. It is t...
In the fast-evolving field of artificial intelligence, Large Language Models (LLMs) have rapidly transformed how we approach language processing. These models, such as ChatGPT, Claude, and Bard, have proven their utility across a range of application...
Amazon S3 is a powerful, scalable storage service, but when multiple clients or processes attempt to write to the same S3 object simultaneously, things can get tricky. Since S3 doesn’t natively handle concurrent writes or provide object locking, it’s...
When working with distributed systems in a microservice architecture, we must always architect our services with failure in mind. When the transaction happens between a microservice, we have to handle the failures. The Saga pattern can be used in a f...
AWS Serverless Application Model (SAM) is a framework for building serverless applications on AWS. It provides a simplified way to define and deploy AWS Lambda functions, Amazon API Gateway APIs, and other serverless resources, using AWS CloudFormation. One of the critical components of AWS SAM is the AWS SAM template, which describes your serverless application and its resources.
AWS intrinsic functions in AWS SAM templates are a powerful feature that allows you to dynamically generate values at runtime based on the context of your application. These functions are provided by AWS CloudFormation and can be used in your AWS SAM templates as well.
In this blog post, we will explore the basics of AWS intrinsic functions in AWS SAM templates and how you can use them to build dynamic and flexible serverless applications on AWS.
AWS Intrinsic Functions in AWS SAM templates are a set of special functions that allow you to generate values dynamically at runtime based on the context of your serverless application. These functions are provided by AWS CloudFormation, which is the underlying service on which AWS SAM templates are built. It can be used to simplify the creation and management of serverless resources in your AWS SAM templates.
AWS Intrinsic Functions in AWS SAM templates allow you to create dynamic and flexible serverless applications on AWS. They allow you to reference other resources, perform string manipulation, and even generate random numbers, among other things. By leveraging these functions, you can reduce duplication, increase reusability, and simplify the management of your serverless resources.
Let's discuss some of the commonly used AWS intrinsic functions in AWS SAM templates.
Ref is an intrinsic function in AWS SAM templates that are used to reference other resources in your template. It returns the value of the named resource or parameter.
When you use Ref in your AWS SAM template, AWS CloudFormation automatically resolves the reference to the value of the named resource or parameter at deployment time. This means that you can use Ref to get the ARN, ID, or other attributes of a resource in your template.
Here's an example of how you can use Ref in your AWS SAM template:
Resources:
MyBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: my-bucket
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my-lambda-function
Handler: index.handler
Runtime: nodejs14.x
Environment:
Variables:
BucketName: !Ref MyBucket
In this example, we have defined an S3 bucket named "MyBucket" and a Lambda function named "MyLambdaFunction". The Lambda function has an environment variable named "BucketName" that references the S3 bucket using Ref. This allows us to dynamically set the bucket name in our Lambda function based on the name of the S3 bucket resource defined in our AWS SAM template.
Fn::Sub is an intrinsic function in AWS SAM templates that are used to substitute variables in a string with their corresponding values at deployment time. It allows you to create more flexible and dynamic templates that can adapt to different environments and configurations. The syntax for Fn::Sub is as follows:
!Sub string [ variablesMap ]
The string parameter is the string that you want to substitute variables in. The variablesMap parameter is an optional map that defines the variables and their values that you want to substitute. Here's an example of how you can use Fn::Sub in your AWS SAM template:
Resources:
MyBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub ${EnvironmentName}-my-bucket-${AWS::Region}
In this example, we have defined an S3 bucket named "MyBucket" with a dynamic bucket name that includes the environment name and AWS region. The environment name is a variable defined in the variables map using the !Sub intrinsic function. The AWS::Region variable is automatically provided by AWS CloudFormation.
In some cases, you may want to conditionally create resources based on certain criteria. AWS Intrinsic Functions such as Fn::If and Fn::Equals allow you to define conditions and control the creation of resources accordingly. For example, you can conditionally create an S3 bucket only if a specific parameter is set to true, or you can enable different features based on the environment or deployment stage.
Resources:
MyBucket:
Type: AWS::S3::Bucket
Condition: CreateBucketCondition
Properties:
...
Conditions:
CreateBucketCondition: !Equals [!Ref CreateBucket, "true"]
In this example, the Fn::Equals function is used to conditionally create an S3 bucket based on the value of the CreateBucket parameter.
SAM templates often require exchanging data between resources or accessing outputs from other AWS CloudFormation stacks. AWS Intrinsic Functions provide powerful capabilities for manipulating input and output data within your templates.
When you have multiple AWS CloudFormation stacks that need to communicate with each other, you can use the Fn::ImportValue function to reference outputs from other stacks. This function allows you to retrieve values exported from another stack and use them as input for your resources. For example:
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
Environment:
Variables:
API_URL: !ImportValue MyApiStack-ApiUrl-${Stage}
...
In this example, the Fn::ImportValue function is used to retrieve the API URL from the MyApiStack stack's output and assign it to the API_URL environment variable. This enables your serverless function to interact with the API exposed by the MyApiStack.
In some cases, you may have an array of values and only need to extract specific elements. The Fn::Select function allows you to retrieve a single element from a list based on its index. For example:
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
Environment:
Variables:
Region: !Select [0, !Split ["-", !Ref AWS::Region]]
...
In this example, the Fn::Select function is used to split the AWS::Region value using the dash ("-") as the separator and then select the first element from the resulting array. This can be useful when you need to extract a specific portion of a value for configuration purposes.
SAM templates often require accessing specific attribute values from resources. The Fn::GetAtt function allows you to retrieve specific attributes of a resource. For example:
Resources:
MyBucket:
Type: AWS::S3::Bucket
Properties:
...
MyBucketName:
Type: AWS::SSM::Parameter
Properties:
Type: String
Value: !GetAtt MyBucket.Name
...
n this example, the Fn::GetAtt function is used to retrieve the Name attribute of the MyBucket resource and assign it as the value for an AWS Systems Manager Parameter (AWS::SSM::Parameter). This enables you to store and reference the bucket name in a parameter that can be used by other resources.
By leveraging these AWS Intrinsic Functions for input and output data manipulation, you can create more dynamic and interconnected serverless applications within your SAM templates. These functions enable you to exchange data between resources, retrieve specific attribute values, and perform transformations to adapt the data for your application's needs.
AWS Intrinsic Functions provide powerful capabilities for manipulating input and output data within SAM templates. Whether you need to reference outputs from other stacks, select specific elements from arrays, or retrieve attribute values from resources, these functions allow you to effectively exchange and transform data within your serverless applications. By incorporating input and output data manipulation using AWS Intrinsic Functions, you can enhance the flexibility and interoperability of your SAM templates, leading to more robust and scalable serverless applications on AWS.