Learn to Use AWS Lambda to Interact with DynamoDB

Table of Contents

1. Introduction
2. Creating a Table in DynamoDB
3. Setting up Lambda Function
4. Writing Data to DynamoDB
5. Reading Data from DynamoDB
6. Modifying Callbacks for API Response

Introduction

In this tutorial, we will learn how to connect an AWS Lambda function to DynamoDB. We will cover the process of creating a table in DynamoDB, setting up a Lambda function, writing data to DynamoDB, and reading data from DynamoDB. We will also discuss how to modify callbacks for an API response.

Creating a Table in DynamoDB

To connect our AWS Lambda function to DynamoDB, we first need to Create a table in DynamoDB. Here are the steps to create a new table:

1. Go to the DynamoDB service in the AWS console.
2. Click on the "Create Table" button on the dashboard.
3. Name your table (e.g., "message").
4. Choose a primary key for your table. In this example, we will use a GUID as the primary key, which will come from a request ID. Let's name the primary key "messageId" and select "STRING" as the data Type.
5. Keep the other settings as default and click on "Create".

Once the table is created, You can view its details, including the Amazon Resource Name (ARN), which can be used to restrict Lambda functions to write to a specific table.

Setting up Lambda Function

Now that we have created a table in DynamoDB, let's set up our Lambda function to write data to the table. Follow these steps:

1. Go to the AWS Management Console and navigate to the Lambda service.
2. Click on "Create Function" to create a new function.
3. Give your function a name, such as "writeMessage".
4. Choose "Author from scratch" as the blueprint.
5. Select "Node.js" as the runtime.
6. Click on "Create Function".

Once the function is created, we can start modifying its code to write data to DynamoDB.

Writing Data to DynamoDB

To write data to DynamoDB from our Lambda function, we need to modify the code within the Lambda function. Here are the steps:

1. Import the required SDK by adding the following code declaration at the beginning of the code:

   const AWS = require('aws-sdk');

2. Connect to DynamoDB by declaring a constant, ddb, as a new instance of the AWS.DynamoDB.DocumentClient. Specify the region where your DynamoDB table exists.

   const ddb = new AWS.DynamoDB.DocumentClient({ region: 'us-east-1' });

3. Modify the function handler to write to DynamoDB. Update the requestId to use the AWS request ID or generate a new GUID. Define a new function, createMessage, that takes the requestId as a parameter and sets up the parameters for writing to DynamoDB.

   
   const requestId = context.awsRequestId;

const createMessage = async (requestId) => { const params = { TableName: 'message', Item: { messageId: requestId, message: 'hello from lambda' } };

return ddb.put(params).promise(); };

4. Update the handler to call the `createMessage` function, returning a response with a status code of 201 if successful, or an error message if an error occurs.
```javascript
exports.handler = async (event, context, callback) => {
  const requestId = context.awsRequestId;

  try {
    await createMessage(requestId);
    callback(null, {
      statusCode: 201,
      body: '',
      headers: {
        'Access-Control-Allow-Origin': '*'
      }
    });
  } catch (error) {
    console.error(error);
    callback(error);
  }
};

Reading Data from DynamoDB

In order to Read data from DynamoDB using Lambda, follow these steps:

1. Create a new Lambda function by repeating the steps Mentioned earlier.

2. Modify the function handler to include a readMessage function that will scan the database and retrieve the messages.

   const readMessage = async () => {
   const params = {
   TableName: 'message',
   Limit: 10
   };
   
   const data = await ddb.scan(params).promise();
   return data.Items;
   };

3. Update the handler to call the readMessage function, returning the retrieved messages in the response.

   exports.handler = async (event, Context, callback) => {
   try {
   const messages = await readMessage();
   callback(null, {
     statusCode: 200,
     body: JSON.stringify(messages),
     headers: {
       'Access-Control-Allow-Origin': '*'
     }
   });
   } catch (error) {
   console.error(error);
   callback(error);
   }
   };

Modifying Callbacks for API Response

If you want the response to return through an API instead of logging it to the console, you can modify the callbacks. Here are the steps:

1. Modify the successful callback to return a response with a status code of 200 and the retrieved messages as the body.
2. Modify the error callback to catch the error and log it to the console.

With these modifications, the Lambda function will return the response through the API, including the retrieved messages if successful.

Highlights

• Learn how to connect an AWS Lambda function to DynamoDB.
• Create a table in DynamoDB to store data.
• Set up a Lambda function to write data to DynamoDB.
• Read data from DynamoDB using a Lambda function.
• Modify callbacks for an API response.
• Handle errors and log them to the console.

FAQs

Q: Can I restrict my Lambda function to write to a specific DynamoDB table?
A: Yes, you can restrict your Lambda function by using the Amazon Resource Name (ARN) of the table. In the IAM role permissions, specify the ARN of the table in the DynamoDB policy.

Q: What data types can be used as the primary key in DynamoDB?
A: DynamoDB supports multiple data types for the primary key, including string, number, and binary. In this example, we used a string as the primary key.

Q: Can I modify the number of items retrieved when reading from DynamoDB?
A: Yes, you can modify the Limit parameter in the scan function to retrieve a specific number of items from the table. By default, it retrieves a maximum of 10 items.

Q: How can I handle errors when writing or reading from DynamoDB?
A: By using try-catch blocks, you can catch any errors that occur during the write or read operations and log them to the console. This helps in troubleshooting and debugging any issues with the DynamoDB operations.