Tutorial: Getting Started with AWS Lambda and Node.js

AWS Lambda is an incredible tool that works well with an abundance of other services on AWS. In this hands-on walkthrough, we’ll show you how to get started and create your first Node.js AWS Lambda function.

Once upon a time, not so long ago, a word caught my ear. Lambda. That struck a chord, remembering the good old days of playing Half-Life as a kid. Little did I know what AWS Lambda was and how incredibly awesome it is. If you’re intrigued, stick around. I’ll only take a few minutes out of your already busy day, and you surely won’t mind.

Function as a Service (FaaS)

Let’s jump right in. The architecture AWS Lambda belongs to is called either serverless computing or Function as a Service. It’s groundbreaking because of the lack of servers. That sounds strange. Well, the code is not running on potatoes, is it!? Okay, that’s just a saying. What’s going on is that you, the developer, don’t need to worry about the infrastructure your code is running on. You deploy the code into the cloud, and it handles the creation of all required resources by itself. But how? Containers!


No, not those. These!

docker containerDocker is the world’s leading software container platform. Developers use Docker to eliminate “works on my machine” problems when collaborating on code with co-workers. Operators use Docker to run and manage apps side-by-side in isolated containers to get better compute density. Enterprises use Docker to build agile software delivery pipelines to ship new features faster, more securely, and confidently for Linux, Windows Server, and Linux-on-mainframe apps

Every time a Lambda Function is created, a container is spun up to serve it. It’s not a Docker container, though. Instead, Lambda uses Firecracker, a lightweight open-source VM implemented in Rust. I just used the example so you would understand it a bit easier.

The code is deployed into the Lambda service and then executed. Hence making every subsequent request faster because AWS is skipping the initial creation of the VM if it already exists.

Creating your first Node.js AWS Lambda function

Before you can even see the code, you need to create a new function in the AWS console. Which means you need an AWS account. If you don’t have an account, don’t hesitate to create one, they have incredible free tiers that include various services and last up to 12 months.

Moving on, fire up a browser and navigate to your account. From there, you need to find Lambda. Press the services dropdown and select Lambda

aws lambda

You’ll land on the Lambda homepage with a big orange button prompting you to create a new function. Well, don’t keep it waiting any longer; click it!

aws lambda create function

This will take you to the main function creation wizard. This example will cover a basic function that will simulate a dice throw; let’s forget about the blueprints and just author one from scratch.

Awesome! You just need to add a name and role for the function and finally start writing some code. Regarding the role, feel free to pick an existing role such as lambda_basic_execution. It will more than suffice for this simple example. Make sure not to forget to add Node.js 14.x as the runtime. Finally, go ahead and create the function.

create from scratch

Great! Now you’re finally seeing some code. Much better. Let’s dive in.

There are several options to take into consideration. The code entry type option sets how you will add code to the function. It can either be inline, upload a ZIP file, or upload from S3. We’ll be using the first option, editing inline. For small functions, it’s okay to write code inline. But when you have more code, it gets very tiresome. That’s why there is a ZIP upload option which we will touch upon later as well.

Set the runtime to Node.js 14.x, which is the latest supported version of Node.js for Lambda at the time of this writing. The handler can stay the same as well. The index stands for the file’s name, while the handler is the function’s name.

roll dice function

With previous versions of Node.js on AWS Lambda (6.10), there were 3 main parameters:

  • The event parameter contains the current event info. That means the event that triggers the function will send along information to the function to use. An example would be the data an HTTP request sends along to the endpoint, such as whether it has request parameters or a body.
  • The context contains all the information about the function itself. How long it has been running, how much memory it’s consuming among other things. This is viewed as the runtime information.
  • The callback is pretty self-explanatory. When you want to tell the function to end its execution, you invoke the callback. It takes two parameters, the first is an error, the second is the data you wish to send back as the response of the Lambda function.

Things have changed with Node.js 8.10 because of the addition of async/await support. The handler can now accept a promise value. This is why we can now assign an async function to the handler, and return a promise directly. No more stupid callback parameters. So awesome!

Writing some logic

That’s enough with the setup for now. Let’s code something.

We’re starting with this snippet of code. The goal is to write a piece of code that will mimic the roll of a dice.

exports.handler = async (event) => {
  // TODO implement
  return 'Hello from Lambda';

Here goes nothing.

exports.handler = async (event) => {
  const min = 1;
  const max = 6;    
  const randomNumber = Math.floor(
    Math.random() * (max - min + 1)
  ) + min;
  const message = 'Your dice throw resulted in: ' +
  return message;

Nice! That does the trick. Now the function will return a random number between 1 and 6. With that out of the way

Nice! That does the trick. Now the function will return a random number between 1 and 6. 

With that out of the way, let’s test it. Press the orange test button and proceed to create a simple test event. Give it a funky name for no particular reason, just for the fun of having a test event named FunkyName. Now you can go ahead and test the function. After pressing the test button, you’ll see something like this.

lambda execution result

The section bordered with the dashed outline shows the function output, more precisely, the function’s return value.

That was fun! You now have a roll a dice function but no way of triggering it outside of AWS yet.

Connecting an API

Here comes the crucial part. How do you think a Lambda function knows how to start its execution? Voodoo? Magic? No, sadly not. An event triggers every function invocation. When an image gets uploaded to S3, an Amazon Alexa skill is executed, or just a regular HTTP request.

Let’s create an HTTP event and tell it to invoke our function. To do this, you first need to jump over to API Gateway in the AWS console. In the services dropdown, pick API Gateway, and you’ll land here.

api gateway

You’ll immediately be prompted to create an API. Ignore all the suggestions and just pick New API and input a name for your API. I’m going to stick with FunkyApi; it just sounds right. Go ahead and hit create.

apigateway new api

Now comes the fun part. Finally, get to hook up the API to the function. First, press the Actions dropdown and pick Create method. You’ll see another smaller dropdown show up. Press it, and choose GET. Set the integration type to Lambda Function, select the region where you created the function and write the name of your function.

GET setup

Hit save and rejoice!

The API is set up and ready. You now only need to deploy it. Press the Actions dropdown once again and hit Deploy API. Pick a new Deployment Stage, write down dev as the stage name, and you’re ready to deploy the API.

deploying API

Finally! The API endpoint is ready. You now have access to the Invoke URL on the dev Stage Editor.


Feel free to open up the API endpoint in a browser window and check the output. What do you see? No, really, what do you see? A random number between 1 and 6 should be returned. 

How awesome is this!? 

In less than 5 minutes, you’ve created a Lambda function, connected it to API Gateway, and created an endpoint to be consumed whenever you like.

Uploading code with a ZIP

What if you need to use some modules from NPM? You can’t add them inline. There has to be a way of running code with dependencies. Well, there is, but it’s a bit tricky to get right. Nevertheless, let’s get on with it!

First of all, create a directory and initialize npm.’

$ mkdir roll-a-dice && npm init -y

Once you’ve done this, go ahead and install moment, a simple date library.

$ npm install moment --save

This will create a node_modules folder with the required dependencies. To include them, you need to compress all the files and upload the ZIP file to Lambda.

Important Note: Only compress the files and folders inside of the project directory. Do NOT zip the whole folder. If you do, it will break the configuration, and the Lambda function will fail!

Before you go ahead and compress the files, add some code with the new npm module you just installed to make sure the Lambda function uses it.
Create a new file in the project directory and name it index.js. Paste the existing Lambda function from AWS into the file and edit it slightly.

const moment = require('moment');
exports.handler = async (event) => {
  const min = 1;
  const max = 6;
  const randomNumber = Math.floor(
    Math.random() * (max - min + 1)
  ) + min;
  const now = moment().format();
  const message = 'Your dice throw resulted in ' + 
    randomNumber + ' and was issued at ' + now;
  return message;

Save all the files and go ahead and zip them up. Remember, only the files and folders within the roll-a-dice directory.

You now have a ZIP file. Go ahead and jump back to the AWS Console.

uploading function code

Change the code entry type to Upload a ZIP file and upload the file you just recently compressed. Great! Now, scroll back to the top of the page and press the big orange button once again to Save and Test the function.

log success

Nice! It works, and it shows the current date and time. You zipped the function and npm module correctly. Just in case, jump back to a browser window and try the endpoint once again. It should now show the updated message.

Monitoring AWS Lambda

What about having insight into your function? Easy, there’s a Monitoring tab! Here you can check out metrics about your function’s behavior.

function monitoring

But, it can get a bit hard to have proper insight when you have multiple functions. In that case, you might want to check out an AWS Lambda monitoring reporting tool like Dashbird, IOPipe, Datadog, or something similar.
Here’s an example of how Dashbird gives you a good dashboard of your AWS Lambda Functions.

What Now? Start Coding!

AWS Lambda is an incredible tool that works well with an abundance of other services on AWS. Lambda functions can be invoked in response to events like file uploads; they can also be used for chatbots, REST APIs, and much, much more.

This simple API example we coded above is just the beginning. But you can see the point. So much overhead is avoided by just worrying about the code, not caring about the underlying infrastructure. I urge you to continue playing with this technology as it will only get more popular in the time to come. Just start coding. Whatever it may be, it doesn’t matter. Just start writing code because you will learn the most by doing it yourself.

We at Dashbird want to create a more welcoming environment for creating serverless apps by making tracking errors a walk in the park. If you have any questions feel free to let me know in the comments below.
If you missed any of the steps above, here’s the repository with all the code.

Further reading:

How to deploy a Node.js application to AWS Lambda using Serverless Framework

Top 6 AWS Lambda monitoring tools

AWS Lambda Node.js errors and exeptions

Read our blog

ANNOUNCEMENT: new pricing and the end of free tier

Today we are announcing a new, updated pricing model and the end of free tier for Dashbird.

4 Tips for AWS Lambda Performance Optimization

In this article, we’re covering 4 tips for AWS Lambda optimization for production. Covering error handling, memory provisioning, monitoring, performance, and more.

AWS Lambda Free Tier: Where Are The Limits?

In this article we’ll go through the ins and outs of AWS Lambda pricing model, how it works, what additional charges you might be looking at and what’s in the fine print.

More articles

Made by developers for developers

Dashbird was born out of our own need for an enhanced serverless debugging and monitoring tool, and we take pride in being developers.

What our customers say

Dashbird gives us a simple and easy to use tool to have peace of mind and know that all of our Serverless functions are running correctly. We are instantly aware now if there’s a problem. We love the fact that we have enough information in the Slack notification itself to take appropriate action immediately and know exactly where the issue occurred.

Thanks to Dashbird the time to discover the occurrence of an issue reduced from 2-4 hours to a matter of seconds or minutes. It also means that hundreds of dollars are saved every month.

Great onboarding: it takes just a couple of minutes to connect an AWS account to an organization in Dashbird. The UI is clean and gives a good overview of what is happening with the Lambdas and API Gateways in the account.

I mean, it is just extremely time-saving. It’s so efficient! I don’t think it’s an exaggeration or dramatic to say that Dashbird has been a lifesaver for us.

Dashbird provides an easier interface to monitor and debug problems with our Lambdas. Relevant logs are simple to find and view. Dashbird’s support has been good, and they take product suggestions with grace.

Great UI. Easy to navigate through CloudWatch logs. Simple setup.

Dashbird helped us refine the size of our Lambdas, resulting in significantly reduced costs. We have Dashbird alert us in seconds via email when any of our functions behaves abnormally. Their app immediately makes the cause and severity of errors obvious.