AWS Lambda How to Create A Function

Creating Lambda functions using the console:

In the following tutorial we will be learning how to create a function from our Lambda console. After that, we will get to invoke this Lambda function with some sample event data.

Your Lambda will be executing the function and returning its results. When this is done, you will have to verify those execution results and the created logs along with different CloudWatch metrics.

How to get a Lambda function created?

1. Go straight to the AWS Lambda console.
   

   AWS Lambda How to Create a Function – AWS Lambda Console

2. Click on Create a function.
   

   AWS Lambda How to Create a Function – AWS Lambda Create A Function

3. In Function name, enter the following name for your function:

my-function.

4. Click on Create function.
   

   AWS Lambda How to Create a Function – AWS Lambda Click Create Function

What happens now?

Lambda will be creating a Node.js function as well as an execution role which will be giving your function the required permission for uploading logs. Also, Lambda will be assuming the execution role upon invoking the function, then creates with it the credentials for SDK and reading data from event sources.

How to Use the designer?

Your Designer will display for you the following:

– Function’s overview

– Function’s upstream resources
– Functions downstream resources

The Designer helps you in configuring the following: layers, destinations and triggers.

You can click on my-function which is found in the designer so that you get back to the configuration and code of your function. When using scripting languages, your Lambda will give you some sample code which is capable of returning a success response.

How to Invoke Lambda function?

Invoke your Lambda function using the sample event data provided in the console.

For invoking a function, follow the below listed steps:

1. Select Test from the top right.
   

   AWS Lambda How to Create a Function – AWS Lambda Test Button

2. From Configure test event page, select the option Create new test event then for the Event template, do not change the default option for Hello World. Type in a unique Event name then take into consideration the below shown sample event template:
3. {
4. “key3”: “value3”,
5. “key2”: “value2”,
6. “key1”: “value1”

}

It is possible to put different key and values in the sample JSON yet without changing any of the event’s structure. In case of choosing to change specific keys and values, it will be required for you to update your sample code with the newly entered parameters.

7. Click on Create then select Test. Every single user is capable of creating up to ten test events for each function and they will not be available to different users.
8. Your function will get executed by Lambda for you and the lambda function handler will receive then it will start processing the sample event.
9. When the execution succeeds, go and check the results using the console.

– Execution result: displays succeeded execution status and the results for your function execution which get returned using the return statement.

– Summary: displays key data which is found in the section of Log output under the REPORT line shown in execution log.

– Log output: displays log generated by Lambda upon every execution. Those generated logs are the ones Lambda Function writes to CloudWatch and they are displayed by the Lambda console to simplify things for you.

Keep in mind the fact that the Click here link will display logs using the CloudWatch console and then the function is going to add logs to CloudWatch inside the log group which is associated with the Lambda function.

10. You will need to run your Lambda function a couple of times for the sake of getting a few metrics for viewing up next.
11. Click on Monitoring where you will be able to check graphs for specific metrics sent by Lambda to CloudWatch.
    

    AWS Lambda How to Create a Function – AWS Lambda CloudWatch Metrics

How to perform the Clean up?

If you are done working with the example function, delete it. You can also delete the execution role that the console created, and the log group that stores the function’s logs.

Deleting Lambda function:

1. Go to the Lambda console and open your Functions page.
2. Select one of the functions.
3. Click on Actions, then select the option Delete function.
4. Click on Delete.

Deleting log group of the function:

1. Go to the CloudWatch console and head to the Log groups page.
2. Select the log group of the function which looks like this /aws/lambda/my-function.
3. Click on Actions, then select the option Delete log group.
4. Click on Yes, Delete.

Deleting execution role of the function:

1. Go to the IAM console and open the Roles page.
2. Select the role of the function which looks like this my-function-role-31exxmpl
3. Click on Delete role.
4. Select the option Yes, delete.

You can automate Cleanup and creation of functions, log groups and roles using CloudFormation and CLI.

 

How to perform Dependency management with layers?

It’s possible to locally install libraries and add them to the deployment package uploaded to Lambda, yet you need to know that doing so actually has its bad sides and some of which are:

– Bigger files will increase your deployment times

– It will not allow you to use the Lambda console for testing changes to your function code

How to solve this?

You will need to make sure that your deployment package as small as possible while avoiding the uploading of unchanged dependencies, and this way, the sample application will get to create a Lambda layer and get it associated with the selected function.

Example of a blank-nodejs/template.yml Dependency layer

Resources:

function:

Type: AWS::Serverless::Function

Properties:

Handler: index.handler

Runtime: nodejs12.x

CodeUri: function/.

Description: Call the AWS Lambda API

Timeout: 10

# Function’s execution role

Policies:

– AWSLambdaBasicExecutionRole

– AWSLambdaReadOnlyAccess

– AWSXrayWriteOnlyAccess

Tracing: Active

Layers:

        – !Ref libs

  libs:

    Type: AWS::Serverless::LayerVersion

    Properties:

      LayerName: blank-nodejs-lib

      Description: Dependencies for the blank sample app.

      ContentUri: lib/.

      CompatibleRuntimes:

        – nodejs12.x

2-build-layer.sh script: It will install the dependencies of your function using npm then add them to a folder having the necessary structure for Lambda runtime.

Example of 2-build-layer.sh How to prepare the layer?

#!/bin/bash

set -eo pipefail

mkdir -p lib/nodejs

rm -rf node_modules lib/nodejs/node_modules

npm install –production

mv node_modules lib/nodejs/

When the sample application gets deployed, the CLI will package the layer apart from the function code, then it goes ahead with deploying them.

When performing subsequent deployments, you will find that the layer archive will merely get uploaded in case the lib folder includes changed contents.

AWS lambda Synchro or Asynchro

 

AWS Lambda: Synchronous or Asynchronous

Synchronous or Asynchronous?

Synchronous or Asynchronous Invocations are the 2 types of Invocations used by Lambda.

Upon executing code within Lambda, you may invoke your functions synchronously or asynchronously. They are both useful and required for various situations, but are accompanied with interesting side effects as well in your serverless space.

Synchronous functions:

– Utilized for discovering what the result of an operation is even prior to carrying on along to your next one.

– Simple just like invoking one function which performs a calculation and later on utilizes its result in the other function.

– Easier and simpler for handling and keeping track of since they mainly get invoked each one on its own after the other, in order.

– Provide you with the result of a function right before heading on to the following other one in order not to worry about getting any data missing.

At other times, it wouldn’t even matter what response you would get; it is simply satisfactory to discover your function has gotten fired and is now running perfectly well. In this case, you should rely on asynchronous functions for your invocations. An example of when its good for you to be choosing to run an asynchronous function is when you’d like to start a video encoding process. Lambda then sends a response stating that your video encoding function was invoked and has begun successfully. Since this function is asynchronous, you will receive this response right after the process starts, rather than needing to keep waiting up till the process finishes.

Functions that get invoked synchronously or asynchronously within Lambda get handled in various ways in case of failure, and this may inflict a couple of unexpected side effects in the logic of your program. In the case of synchronously invoking your functions directly, then the invoking application used will be held responsible for every single one of the retries. While relying on integrations you will find that they might include extra retries that come built in. Functions which get invoked asynchronously will not be relying on any invoking application for their retries, because the retries here will be built in and running automatically. The invocation shall get retried two times while having delays in-between. In case both retries end up in failure, the event will get discarded. Asynchronous invocations allow you to create a Dead Letter Queue that may be utilized for keeping the failing event from getting discarded. A Dead Letter Queue provides you with the opportunity to send unprocessed events to an Amazon SQSor SNS queue so that you get to build some logic to start dealing with.

 

Synchronous Invocation

Upon the invocation of a function synchronously, Lambda will run the function and await a response. Upon the finish of the function execution, Lambda will return a response from the function’s code holding extra data, like the executed function’s version. For invoking a function synchronously using the CLI, utilize the following command: invoke.

$ aws lambda invoke –function-name my-function –payload ‘{ “key”: “value” }’ response.json

{

“ExecutedVersion”: “$LATEST”,

“StatusCode”: 200

}

This below diagram displays the way clients invoke their Lambda functions synchronously. Lambda tends to send the events in a direct manner to your function and then starts sending the function’s response to its invoker.

The payload refers to a string containing an event found in the JSON format. The file that get the response written by CLI from the function is called response.json. In the case of returning an object or error, the response will be that object or error sent in the JSON format. In case the function ends up exiting without error, its response will be null.

Output from command: shown in the terminal and contains data from headers found in the response coming from Lambda, including the version in which the event was processed (useful for aliases), and the status code which is sent back by Lambda. In case Lambda runs the function, 200 is what the status code will be, regardless if an error gets returned by the function.

In the case that Lambda fails to run the function, the error is going to get displayed in the output.

$ aws lambda invoke –function-name my-function –payload value response.json

An error occurred (InvalidRequestContentException) when calling the Invoke operation: Could not parse request body into json: Unrecognized token ‘value’: was expecting (‘true’, ‘false’ or ‘null’)

at [Source: (byte[])”value”; line: 1, column: 11]

Rely on the –log-type option for getting logs for your invocation coming from the command line. Included in the response is a LogResult field which has up to 4 KB of base64-encoded logs from that invocation.

$ aws lambda invoke –function-name my-function out –log-type Tail

{

“StatusCode”: 200,

“LogResult”: “U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb…”,

“ExecutedVersion”: “$LATEST”

}

It’s possible to utilize the base64 utility for decoding the logs.

$ aws lambda invoke –function-name my-function out –log-type Tail \

–query ‘LogResult’ –output text |  base64 -d

START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST

“AWS_SESSION_TOKEN”: “AgoJb3JpZ2luX2VjELj…”, “_X_AMZN_TRACE_ID”: “Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0″”,ask/lib:/opt/lib”,

END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8

REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 100 ms         Memory Size: 128 MB     Max Memory Used: 73 MB

Asynchronous Invocation

When a function is invoked asynchronously, waiting for a response to arrive from the function code is not necessary. The event gets handed off to Lambda and Lambda will be handling the rest. The way that Lambda handles errors may be configured, and it’s possible to send invocation records to reach a downstream resource for the sake of chaining together the components of your used application.

In the below diagram you can see clients invoking a Lambda function asynchronously. Lambda tends to queue its events prior to sending them to functions.

Asynchronous invocation:

The event gets placed by Lambda in a queue and then a success response is returned with absolutely no additional information. Another different process will be reading events from that queue and then sending them straight to your function. For getting a function invoked asynchronously, you must set the invocation type parameter to the following: Event.

$ aws lambda invoke –function-name my-function  –invocation-type Event –payload ‘{ “key”: “value” }’ response.json{    “StatusCode”: 202}

Output file is (response.json) and it will not contain any kind of data, but it will still be  created upon running this command. In case the event was not added by to the queue, the error message will be displayed in the command output.

Lambda manages the function’s asynchronous event queue and attempts to retry on errors. In case an error is returned, Lambda will run the function an extra 2 more times, while having to wait for 1 minute in between the first 2 attempts being made, and 2 minutes in between the 2nd and 3rd attempts made. Function errors will be including errors that get returned through the function’s code and errors that get returned through the function’s runtime, for example: timeouts.

In case the function did not include enough concurrency available for processing every single event, some additional requests will get throttled.

The below example displays an event which got successfully added to the queue, but remains pending for a whole one hour late because of throttling.

It’s also possible to get Lambda configured for sending an invocation record to a different service. The below destinations are supported by Lambda for asynchronous invocation.

• Amazon SQS: queue.
• Amazon SNS: topic.
• AWS Lambda:
• Amazon EventBridge: event bus.

Invocation record:

– Includes detailed information regarding the request and response all in a JSON format. – It’s possible to get separate destinations configured for events which get processed in a successful manner, and the events which tend to fail every processing attempt.

– It’s possible to get an SQS queue or SNS topic configured as a dead-letter queue for an discarded event whatsoever.

– Lambda will merely be sending for dead-letter queues, the content of its events, with no details regarding the response.

what is AWS lambda