
## Table of Contents

1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Create AWS Role for Lambda to Access DynamoDB](#create-aws-role-for-lambda-to-access-dynamodb)
4. [Create Node.js Code for Lambda](#create-nodejs-code-for-lambda)
5. [Prepare Package to Deploy to AWS Lambda](#prepare-package-to-deploy-to-aws-lambda)
6. [Test Lambda Function](#test-lambda-function)
7. [Conclusion](#conclusion)

## Introduction

This blog shows how to create an AWS Lambda with Node.js and insert a record into
DynamoDB. It also shows how to manually deploy Lambda as a package to AWS from your
local development environment.

## Prerequisites

- Have an AWS Account

- Setup AWS CLI Config

- Create AWS DynamoDB Table

- Install Node.js on Mac

## Create AWS Role for Lambda to Access DynamoDB

Here, we'll create a new Lambda policy to access DynamoDB. Go to the AWS Roles
and click Create role.

Choose Lambda service and click add permission.

At the attach permissions policies page, click create policy. You can use
either the visual editor or JSON view. What we are going to do here is provide the
Lambda with DynamoDB PutItem permission. Following is a code snippet showing the JSON view. As you can see, this policy allows the dynamodb PutItem
operation because our code later will use PutItem to add a record to
DynamoDB.

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "dynamodb:PutItem",
            "Resource": "*"
        }
    ]
}
```

## Create Node.js Code for Lambda

Now, we'll go back to our local development environment and write some code. First
we'll need to set up the Node.js package file. You can run the following command to
create a default package file. This will create a
`package.json` file.

### Create package.json File

```
npm init -y
```

### Create Lambda Node.js Code

Run this command to open the command editor.

```
nano index.js
```

At the command editor, paste the following code and save the index.js file. This
will be the file that we'll deploy to Lambda later.

The following assumes we already have a table called
`S3BucketImages`. You can go to AWS DynamoDB to create the
table and make sure the table's region matches your code. Set the Partition
key as UniqueKey.

```
onst AWS = require('aws-sdk');
const dynamodbClient = new AWS.DynamoDB.DocumentClient();

exports.handler = (event, context, callback) => {

    AWS.config.update({
        region:  "us-west-1",
    });

    let putRequest = {
        TableName: 'S3BucketImages',
        Item: {
            "UniqueKey": new Date().toString()
        }
    };

    await dynamodbClient.put(putRequest).promise()
    .then((data) => {
        console.info('successfully update to dynamodb', data)
    })
    .catch((err) => {
        console.info('failed adding data dynamodb', err)
    });

};
```

## Prepare Package to Deploy to AWS Lambda

Now, we'll start to prepare the deployment file as a zip file and deploy it to AWS
using the AWS CLI command line. The code we have only has a dependency on
`aws-sdk`, so let's install it. This will create node_modules in
your local folder.

```
npm install aws-sdk
```

Run this command at your terminal to include our index.js and node_modules and
create a zip file.

```
zip -r index.zip index.js node_modules
```

We'll then run the command below to create a Lambda function. You'll need to replace
the AWS account ID and the role created earlier.

```
aws lambda create-function --function-name my-test-lambda \
--zip-file fileb://index.zip --handler index.handler --runtime nodejs12.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::{Your-AWS-Account-ID}:role/{The-AWS-Role-Can-Access-DynamoDB}
```

## Test Lambda Function

This should be pretty much everything you need to access DynamoDB from Lambda.
You can use the Test tab in the Lambda console to make sure it actually adds a new record
into DynamoDB.

## Conclusion

In this blog, we walked through how to create an AWS Lambda function with Node.js that inserts data into DynamoDB. We also covered how to create the necessary IAM role, package the code, and deploy it manually using the AWS CLI. This approach is useful for quick prototyping or small-scale deployments.


This blog shows how to create an AWS Lambda with Node.js and insert a record into DynamoDB. It also shows how to manually deploy Lambda as a package to AWS from your local development environment.

Use Lambda with Node.js to Insert Data Into DynamoDB


## Table of Contents

- [Introduction](#introduction)
- [Export DynamoDB Table to S3](#export-dynamodb-table-to-s3)
- [Destination Bucket Setup](#destination-bucket-setup)
- [AWS Configure](#aws-configure)
- [Execute the Command](#execute-the-command)
- [Migrate Data from S3 to DynamoDB](#migrate-data-from-s3-to-dynamodb)
- [Conclusion](#conclusion)

## Introduction

This blog shows how to migrate DynamoDB data between different AWS accounts.
You can migrate DynamoDB by using different approaches: 1. AWS S3 with AWS
Glue. 2. Data Pipeline. 3. Amazon EMR. Here, we'll use S3 and focus on how to
move DynamoDB backup data into a different AWS account.

Following is the process of handling migration from one AWS account to another
account and the requirements:

- Have an AWS account to use as the source account.

- The source account has a DynamoDB table and the S3 bucket the DynamoDB table
  will export to.

- Have an AWS account to use as the target account, and the S3 bucket which the
  source account will copy backup DynamoDB files into.

## Export DynamoDB Table to S3

Here, we'll export the DynamoDB table into the S3 bucket. Log in to AWS and
go to the DynamoDB section.

### Enable Point-in-Time Recovery

Before backing up the DynamoDB table to S3, you have to enable PITR
(point-in-time recovery). After enabling PITR, click Export to S3, then
choose the source table you want to back up to the same account's S3.

Enter the destination S3 bucket name and click the export button. The export
should now start and will copy all the backup files for the DynamoDB table
into the S3 bucket. Note that you can back up to a different AWS account
directly, but it's not covered in this blog.

### Add Bucket Policy to Source Bucket

After DynamoDB has been backed up to the S3 bucket, you'll need to modify the
bucket policy. Replace **ACCOUNT-B-ID** with account B's
ID, replace **ACCOUNT-B-USER** with account B's user who
will later perform the S3 file sync.
**ACCOUNT-A-Bucket-Name** should be replaced with the bucket that has the
DynamoDB backup content.

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::{ACCOUNT-B-ID}:user/{ACCOUNT-B-USER}"
            },
            "Action": [
                "s3:ListBucket",
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::{ACCOUNT-A-Bucket-NAME}/*",
                "arn:aws:s3:::{ACCOUNT-A-Bucket-NAME}"
           ]
        }
    ]
}
```

## Destination Bucket Setup

### Setup Custom Policy

For the destination bucket setup, we need to set up a user who has permission
to perform a bucket sync. The following policy grants access to both buckets.

```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket",
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::{source bucket name}/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket",
                "s3:PutObject",
                "s3:PutObjectAcl"
            ],
            "Resource": [
                "arn:aws:s3:::{destination bucket name}/*"
            ]
        }
    ]
}
```

### Create a User and Attach the Policy

In the destination AWS account, create a new IAM user (or use an existing one)
that will be used to run the S3 sync command. Attach the custom policy you
created above to this user. Make sure to generate access keys for this user,
as you will need them in the next step to configure the AWS CLI.

### AWS Configure

Here, you'll run `aws configure` and use the credentials of the user who has
the custom policy attached.

### Execute the Command

At this point, both buckets should be ready and we can run the command to copy
files from account A's bucket to account B's bucket.

```
aws s3 sync s3://{source bucket name} s3://{target bucket name} --source-region {source region} --region {target region}
// following is example
aws s3 sync s3://my-dynamodb-backup s3://my-dynamodb --source-region us-west-2 --region us-west-1
```

### Migrate Data from S3 to DynamoDB

Now the S3 bucket should have the backup DynamoDB tables. There are a few ways
you can handle ETL to migrate data into DynamoDB. You can use a Glue Job
to read the files from the S3 bucket and write them to the target DynamoDB
table, or write a Lambda function to read the S3 files and write them into the
DynamoDB table. Following are a few possible ways to migrate data from S3 to
DynamoDB, but they are not part of this blog.

- Write a Glue Job

- Data Pipeline

- Write a Lambda function

- Use Amazon EMR

## Conclusion

Migrating DynamoDB data between AWS accounts involves exporting the table to
S3, setting up cross-account bucket policies, and syncing the data to the
destination account's S3 bucket. From there, you can use tools like AWS Glue,
Data Pipeline, Lambda, or Amazon EMR to load the data into the target DynamoDB
table. While there are several steps involved, following this process ensures
a reliable and secure migration.


This blog shows how to migrate DynamoDB data between different AWS accounts. You can migrate DynamoDB by using different approaches such as AWS S3 with AWS Glue, Data Pipeline, or Amazon EMR. Here, we'll use S3 and focus on how to move DynamoDB backup data into a different AWS account.

How to Backup DynamoDB Data to Different AWS Account


## Table of Contents

1. [Introduction](#introduction)
2. [Export Table to S3](#export-table-to-s3)
3. [Download Data Zip File](#download-data-zip-file)
4. [Import to Local DynamoDB Table](#import-to-local-dynamodb-table)
5. [Conclusion](#conclusion)

## Introduction

This guide shows how to backup your AWS DynamoDB table (on the cloud) to your local DynamoDB environment. This can be helpful when you want to build a prototype using production data without affecting the live database.

## Export Table to S3

First, log in to the AWS Console and navigate to the DynamoDB main page. Select the table you want to export, then choose **Export to S3 bucket**.

At the time of writing, you need to enable **Point-in-Time Recovery** before you can export to S3. Note that enabling this feature may incur additional charges. Once the export is complete, you can disable it if you no longer need it.

## Download Data Zip File

Once DynamoDB exports the table to S3, you should be able to find your data under:

**{your-bucket}/AWSDynamoDB/{unique-guid}/data**

Download the zip file to your local machine.

The following is a sample of the JSON file downloaded from the S3 bucket. Notice that there is no comma after each item object. You can fix this by simply adding a comma `,` after each item object to make it valid JSON array syntax.

```json
{"Item":{"age":{"S":"16"},"name":{"S":"Clifton Trantow"},"phone":{"S":"325-550-4097"}}}
{"Item":{"age":{"S":"3"},"name":{"S":"Dallas Zulauf"},"phone":{"S":"(201) 844-4314 x024"}}}
{"Item":{"age":{"S":"81"},"name":{"S":"Jim Corkery"},"phone":{"S":"1-615-855-7445"}}}
{"Item":{"age":{"S":"112"},"name":{"S":"Mrs. Lisa Morissette"},"phone":{"S":"451-951-5004 x91302"}}}
{"Item":{"age":{"S":"5"},"name":{"S":"Tami Lind"},"phone":{"S":"(961) 774-0217 x529"}}}
{"Item":{"age":{"S":"38"},"name":{"S":"Michele Corwin"},"phone":{"S":"(516) 496-8378 x38139"}}}
{"Item":{"age":{"S":"64"},"name":{"S":"Cory Renner"},"phone":{"S":"1-866-451-5277 x11173"}}}
{"Item":{"age":{"S":"21"},"name":{"S":"Mr. Hannah Toy"},"phone":{"S":"1-909-356-2256 x160"}}}
{"Item":{"age":{"S":"39"},"name":{"S":"Horace Luettgen"},"phone":{"S":"923.425.3214 x763"}}}
{"Item":{"age":{"S":"81"},"name":{"S":"Jake Johnson"},"phone":{"S":"838-703-7094 x17403"}}}
{"Item":{"age":{"S":"111"},"name":{"S":"Violet McClure"},"phone":{"S":"(476) 838-6678"}}}
{"Item":{"age":{"S":"88"},"name":{"S":"Faith Hoppe"},"phone":{"S":"1-632-638-0225 x871"}}}
{"Item":{"age":{"S":"102"},"name":{"S":"Floyd Kshlerin"},"phone":{"S":"1-465-918-6299 x2042"}}}
{"Item":{"age":{"S":"104"},"name":{"S":"Alvin Moore"},"phone":{"S":"1-885-900-8942 x467"}}}
{"Item":{"age":{"S":"37"},"name":{"S":"Mildred Kuhn"},"phone":{"S":"(681) 776-7208 x982"}}}
{"Item":{"age":{"S":"107"},"name":{"S":"Michele Lubowitz"},"phone":{"S":"(933) 324-2667"}}}
{"Item":{"age":{"S":"51"},"name":{"S":"Ian Weber"},"phone":{"S":"504.392.7656 x729"}}}
{"Item":{"age":{"S":"54"},"name":{"S":"Ms. Randall O'Keefe"},"phone":{"S":"1-860-892-1635"}}}
{"Item":{"age":{"S":"99"},"name":{"S":"Ricky Kutch PhD"},"phone":{"S":"767-631-7777"}}}
{"Item":{"age":{"S":"10"},"name":{"S":"Lynn Collier"},"phone":{"S":"1-868-378-3294 x945"}}}
```

## Import to Local DynamoDB Table

In this step, we load the JSON file downloaded from S3 and insert the data into the local DynamoDB table running on port 8000. You can use DynamoDB's `putItem` or `BatchWriteItem` API to import the data.

The following example uses Node.js and runs on macOS.

```javascript
const fs = require("fs");
const AWS = require("aws-sdk");
function addDataToLocal() {
  AWS.config.update({
    region: "us-west-2",
    endpoint: "http://localhost:8000",
  });

  var dynamodb = new AWS.DynamoDB();
  var readData = {};
  fs.readFile("./MyFakeFriendData.json", (err, data) => {
    if (err) throw err;
    let jsonData = JSON.parse(data);

    jsonData.Items.forEach((item) => {
      var params = {
        TableName: "MyFakeFriend",
        Item: item,
      };

      dynamodb.putItem(params, function (err, data) {
        if (err) {
          console.error("Unable to add data", JSON.stringify(err, null, 2));
        } else {
          console.log("Able to add data", data);
        }
      });
    });
  });
}

addDataToLocal();
```

## Conclusion

This is how you can move a DynamoDB table from the AWS cloud to your local DynamoDB environment. The process involves three main steps:

1. **Export** the table from DynamoDB to an S3 bucket
2. **Download** the exported data zip file from S3
3. **Import** the data into your local DynamoDB using the `putItem` API

This approach is useful for creating local prototypes with real production data, allowing you to develop and test without affecting your cloud resources.


A step-by-step guide on how to backup your AWS DynamoDB table from the cloud to your local DynamoDB environment using S3 export and Node.js.

Backup AWS DynamoDB Table to Local


## Table of Contents

1. [Introduction](#introduction)
2. [DynamoDB Table Schema](#dynamodb-table-schema)
3. [Prepare the Table Data from Local DynamoDB](#prepare-the-table-data-from-local-dynamodb)
4. [JSON Data Output](#json-data-output)
5. [Put Request to Add Data](#put-request-to-add-data)
6. [Conclusion](#conclusion)

## Introduction

This blog shows how to move a DynamoDB local table and data to the DynamoDB Web
Service. Unlike SQL databases, you can't simply use a backup file to restore to a
different environment. So far, at the time of writing, I have not found
any other way to move DynamoDB local data to the AWS Web Service. The following sample
code will loop through each item and use `aws-sdk` to put the request
to the AWS DynamoDB Web Service.

## DynamoDB Table Schema

The following is the sample table schema. You can manually add the table on AWS
DynamoDB or use the SDK to create a table programmatically.

```
var params = {
        TableName : 'MyFakeFriend',
        KeySchema: [
            { AttributeName: "name", KeyType: "HASH" },
            { AttributeName: "age", KeyType: "RANGE" },
        ],
        AttributeDefinitions: [
            { AttributeName: "name", AttributeType: "S" },
            { AttributeName: "age", AttributeType: "S" }
        ],
        ProvisionedThroughput: {
            ReadCapacityUnits: 10,
            WriteCapacityUnits: 10
        }
    };
```

## Prepare the Table Data from Local DynamoDB

This command will scan the entire table **MyFakeFriend** and
output the result to the **data.json** file.

```
aws dynamodb scan --table-name MyFakeFriend --endpoint-url http://localhost:8000 > data.json
```

## JSON Data Output

Now, the following is the result when I run the JSON output command. I have
20 items that need to be added to the cloud DynamoDB service.

```
{
    "Count": 20,
    "Items": [
        {
            "phone": {
                "S": "325-550-4097"
            },
            "age": {
                "S": "16"
            },
            "name": {
                "S": "Clifton Trantow"
            }
        },
        {
            "phone": {
                "S": "923.425.3214 x763"
            },
            "age": {
                "S": "39"
            },
            "name": {
                "S": "Horace Luettgen"
            }
        }
    ],
    "ScannedCount": 20,
    "ConsumedCapacity": null
}
```

## Put Request to Add Data

The following is sample code to loop through DynamoDB local items and put the
request to the cloud AWS DynamoDB service.

```
var AWS = require("aws-sdk");
var fs = require('fs');

function addData() {

    AWS.config.update({
        region: "us-west-2",
        endpoint: "https://dynamodb.us-west-2.amazonaws.com"
      });

    var dynamodb = new AWS.DynamoDB();
    fs.readFile('./data.json', (err, data) => {
        if (err) throw err;
        let jsonData = JSON.parse(data);

        jsonData.Items.forEach(item => {

            var params = {
                TableName: 'MyFakeFriend',
                Item: item
            }

            dynamodb.putItem(params, function(err, data) {
                if (err) {
                    console.error("Unable to add data", JSON.stringify(err, null, 2));
                } else {
                    console.log("Able to add data", JSON.stringify(data, null, 2));
                }
            })
        });
    });
}

addData();
```

## Conclusion

The above approach provides a simple way to migrate DynamoDB data from a local instance to the AWS cloud by scanning the local table, exporting it to JSON, and then programmatically putting each item into the cloud DynamoDB service.


This blog shows how to move a DynamoDB local table and data to the DynamoDB Web Service. Unlike SQL databases, you can't simply use a backup file to restore to a different environment.

Move DynamoDB Table from Local to AWS Cloud


## Table of Contents

1. [Introduction](#introduction)
2. [Create a DynamoDB Table with Node.js](#create-a-dynamodb-table-with-nodejs)
3. [Add Data to a DynamoDB Table with Node.js](#add-data-to-a-dynamodb-table-with-nodejs)
4. [Test Results by Scanning the Table](#test-results-by-scanning-the-table)
5. [Conclusion](#conclusion)

## Introduction

AWS DynamoDB is a NoSQL database service on the cloud. You can create an AWS account, navigate to the DynamoDB section in the AWS Console, and start creating tables and adding items. Unlike SQL databases where you need to set up and manage your own server, AWS manages the server infrastructure for DynamoDB — it is a fully serverless database that you access via HTTP requests.

But what about local development? Just as you can set up a SQL database locally, you can also run DynamoDB on your local machine. You can refer to [this blog post](../blog/post/How-to-setting-up-DynamoDB-locally) for instructions on setting up DynamoDB locally.

This guide will show you how to create a DynamoDB table in your local environment, add data to it, and verify the results.

The following example code uses Node.js running on macOS with npm version **6.12.0** and Node version **v12.13.0**.

## Create a DynamoDB Table with Node.js

The following code requires the `aws-sdk` npm package to interact with DynamoDB from Node.js.

```javascript
var AWS = require("aws-sdk");
function createTable() {
  AWS.config.update({
    region: "us-west-2",
    endpoint: "http://localhost:8000",
  });

  var dynamodb = new AWS.DynamoDB();
  var params = {
    TableName: "MyFakeFriend",
    KeySchema: [
      { AttributeName: "name", KeyType: "HASH" },
      { AttributeName: "age", KeyType: "RANGE" },
    ],
    AttributeDefinitions: [
      { AttributeName: "name", AttributeType: "S" },
      { AttributeName: "age", AttributeType: "S" },
    ],
    ProvisionedThroughput: {
      ReadCapacityUnits: 10,
      WriteCapacityUnits: 10,
    },
  };

  dynamodb.createTable(params, function (err, data) {
    if (err) {
      console.error(
        "Unable to create table. Error JSON:",
        JSON.stringify(err, null, 2),
      );
    } else {
      console.log(
        "Created table. Table description JSON:",
        JSON.stringify(data, null, 2),
      );
    }
  });
}
createTable();
```

Save the code above to a file (for example, `app.js`), navigate to the file's directory, and run the following command:

```
node app.js
```

If there are no errors, you should see the following message in the response:

```
Created table. Table description JSON: {
  "TableDescription": {
    "AttributeDefinitions": [
      {
        "AttributeName": "name",
        "AttributeType": "S"
      },
      {
        "AttributeName": "age",
        "AttributeType": "S"
      }
    ],
    "TableName": "MyFakeFriend",
    "KeySchema": [
      {
        "AttributeName": "name",
        "KeyType": "HASH"
      },
      {
        "AttributeName": "age",
        "KeyType": "RANGE"
      }
    ],
    "TableStatus": "ACTIVE",
    "CreationDateTime": "...",
    "ProvisionedThroughput": {
      "LastIncreaseDateTime": "1970-01-01T00:00:00.000Z",
      "LastDecreaseDateTime": "1970-01-01T00:00:00.000Z",
      "NumberOfDecreasesToday": 0,
      "ReadCapacityUnits": 10,
      "WriteCapacityUnits": 10
    },
    "TableSizeBytes": 0,
    "ItemCount": 0,
    "TableArn": "arn:aws:dynamodb:ddblocal:000000000000:table/MyFakeFriend"
  }
}
```

In this example, we created a DynamoDB table called **MyFakeFriend** with **name** as the partition key and **age** as the sort key.

One of the benefits of setting up DynamoDB locally is that you can prototype and test your schema before deploying to the actual AWS DynamoDB service in the cloud. This is especially important because once you create a table in AWS DynamoDB, you cannot change the primary key, partition key, sort key, or local secondary index. Testing locally first helps you get the schema right before committing to it in production.

## Add Data to a DynamoDB Table with Node.js

After creating the table, the following Node.js code shows how to add random data to it.

Save the following code as `addData.js` and run `node addData.js` from the command line. This script will generate 20 items in the **MyFakeFriend** table. You can modify the maximum item count from 20 to any number you want — for example, tens of thousands of records — so you can perform testing on the local environment before moving to the AWS cloud.

```javascript
var AWS = require("aws-sdk");
var faker = require("faker");

function getAge() {
  return Math.floor(Math.random() * 120) + 1;
}

function addData() {
  AWS.config.update({
    region: "us-west-2",
    endpoint: "http://localhost:8000",
  });

  for (let index = 0; index < 20; index++) {
    var docClient = new AWS.DynamoDB.DocumentClient();
    var params = {
      TableName: "MyFakeFriend",
      Item: {
        name: faker.name.findName(),
        age: getAge().toString(),
        phone: faker.phone.phoneNumber(),
      },
    };

    docClient.put(params, function (err, data) {
      if (err) {
        console.error("Unable to add data", JSON.stringify(err, null, 2));
      } else {
        console.log("Able to add data", data);
      }
    });
  }
}
addData();
```

## Test Results by Scanning the Table

To verify the results, you can run the following AWS CLI command to scan and display all the data in the table:

```
aws dynamodb scan --table-name MyFakeFriend --endpoint-url http://localhost:8000
```

## Conclusion

In this guide, we covered how to work with DynamoDB locally using Node.js:

1. **Create a table** with a defined schema (partition key and sort key)
2. **Add data** using the `DocumentClient` with fake data generated by the `faker` library
3. **Verify results** by scanning the table using the AWS CLI

Setting up DynamoDB locally is a great way to prototype, test, and validate your database schema before deploying to the AWS cloud. It saves time and helps you avoid costly mistakes with immutable table configurations.


A step-by-step guide on how to create a DynamoDB table in your local environment using Node.js, including adding data and testing with scan.

Create DynamoDB Table Locally


## Table of Contents

1. [Introduction](#introduction)
2. [Download DynamoDB](#download-dynamodb)
3. [JRE](#jre)
4. [Start DynamoDB](#start-dynamodb)
5. [Run DynamoDB Command in Background](#run-dynamodb-command-in-background)
6. [Use AWS CLI](#use-aws-cli)
7. [Access Local DynamoDB](#access-local-dynamodb)
8. [Conclusion](#conclusion)

## Introduction

AWS DynamoDB is a document database that provides single-digit millisecond
performance. It is a serverless database, which means you can focus on using
applications to access DynamoDB and AWS will manage the server for you.
It's also available in multiple AWS regions and has built-in Cache DAX.

Another good reason to use DynamoDB is the free tier it provides — up
to 25 GB storage, 25 write capacity units, and 25 read capacity units are
free. Compared to MongoDB, depending on the MongoDB cloud provider, it might be
500 MB of storage if you try to look for a free tier.

Now, in this blog I'll show how to set up DynamoDB locally, and also demonstrate a few
simple commands to access local DynamoDB.

## Download DynamoDB

Go to the following link from AWS to download DynamoDB. Each region has a
different DynamoDB file, so choose the region you'll be using for DynamoDB.
After unzipping the file, run the following command.

[Link to Download DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html)

## JRE

To start DynamoDB locally you'll need at least JRE version 8. You can use the
following link as a reference to download JRE if you don't have it already.

[Download JRE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html)

## Start DynamoDB

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
```

If you see the following, it means your DynamoDB is able to run locally on
port 8000.

```
Initializing DynamoDB Local with the following configuration:
Port:	8000
InMemory:	false
DbPath:	null
SharedDb:	true
shouldDelayTransientStatuses:	false
CorsParams:	*
```

After downloading the DynamoDB file to your local OS, **cd** to the
folder and run the command. It should start DynamoDB on your local machine.
DynamoDB has a few ways to store the database file locally. These are
**-sharedDb**, **-inMemory**, and
**-dbPath**. Let's see what the differences are between these
three.

### Omit Database File Option

If you omit any option, DynamoDB will store the database file with your AWS
access key ID and the region. For instance, you should see a DB file formatted
as **{your AWS access key ID}\_{region}.db** when running the
following command. This file will change if you use a different AWS user by
running **aws configure**.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar
```

Using **-sharedDb** will create a DynamoDB file called
**shared-local-instance.db** when starting DynamoDB.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
```

Now, there's another way to save the DynamoDB file locally by using
**-dbPath {path}**. For example, if you have the following command
with `-dbPath test2` (assume `test2` is a folder), first make
sure the folder exists. Then when you run the following command, you'll see the
**shared-local-instance.db** file in the
`test2` folder.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -dbPath test2
```

Using **-inMemory**, as the name shows, will save the database
file in the OS's memory but will destroy it once you stop DynamoDB locally.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -inMemory
```

So which is better? That depends on what you're using DynamoDB for locally.
If you just want to test something quickly and you don't care where it's stored,
then you can omit the file option or use
**-inMemory**, which destroys the file once you're done with your
task. Or you can use **-dbPath** to create a file path, e.g. dev
or dev2, to store different DynamoDB files for different environments.

### DynamoDB Port Option

By default, DynamoDB uses port 8000, but you can also change the port by using
the following command. If for some reason you need to set up a different
DynamoDB file with a different DynamoDB port, you can use
**-dbPath** with **-port**, since you might have
a large amount of data to test locally before moving to the AWS DynamoDB service.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb -port 8001
```

Furthermore, type help to get all the command options:

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -help
```

This is the output when running the -help option:

```
usage: java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar
            [-port ] [-inMemory] [-delayTransientStatuses]
            [-dbPath ][-sharedDb] [-cors ]
 -cors                       Enable CORS support for javascript against a
                            specific allow-list list the domains separated
                            by , use '*' for public access (default is
                            '*')
 -dbPath             Specify the location of your database file.
                            Default is the current directory.
 -delayTransientStatuses    When specified, DynamoDB Local will introduce
                            delays to hold various transient table and
                            index statuses so that it simulates actual
                            service more closely. Currently works only for
                            CREATING and DELETING online index statuses.
 -help                            Display DynamoDB Local usage and options.
 -inMemory                  When specified, DynamoDB Local will run in
                            memory.
 -optimizeDbBeforeStartup   Optimize the underlying backing store database
                            tables before starting up the server
 -port            Specify a port number. Default is 8000
 -sharedDb                  When specified, DynamoDB Local will use a
                            single database instead of separate databases
                            for each credential and region. As a result,
                            all clients will interact with the same set of
                            tables, regardless of their region and
                            credential configuration. (Useful for
                            interacting with Local through the JS Shell in
                            addition to other SDKs)
```

## Run DynamoDB Command in Background

You can also run your DynamoDB command in the background by appending
**&** as follows. After this command, if you type
`ctrl + c`, you close the terminal but DynamoDB will still run in
the background.

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar &
```

If you wish to switch to the foreground of the DynamoDB command, use
**fg** with the DynamoDB start command. That will bring it to the
foreground, then you can press `ctrl + c` to actually close it if you wish
to stop DynamoDB locally.

```
fg java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar
```

## Use AWS CLI

Once DynamoDB is ready, you can access it via AWS CLI. You can try
listing tables, querying, or updating a table. However, before that, you will
need to run `aws configure` to connect from your local OS to the AWS
service.

### Create a User at AWS Console

Create a user at the AWS console and make sure the user can access DynamoDB.

There are many ways to achieve this. One way is to create a group
that has access to DynamoDB, then create a new user and assign the group to
this user.

Once you run the following command in your command-line tool, type the user's
AWS access key ID and secret access key. Then from your local OS, that
user's credentials will be used to access the AWS service.

```
aws configure
```

## Access Local DynamoDB

Now, you should be able to access local DynamoDB from AWS CLI. Let's try the
following command, which will list all the tables.

```
aws dynamodb list-tables --endpoint-url http://localhost:8000
```

If you see the following output, it means you are able to access your local
DynamoDB.

```
{
    "TableNames": []
}
```

Let's try more — create a table for local DynamoDB.

```
aws dynamodb create-table \
    --table-name User \
    --endpoint-url \
        http://localhost:8000 \
    --attribute-definitions \
        AttributeName=Name,AttributeType=S \
        AttributeName=Job,AttributeType=S \
    --key-schema \
        AttributeName=Name,KeyType=HASH \
        AttributeName=Job,KeyType=RANGE \
    --provisioned-throughput \
        ReadCapacityUnits=5,WriteCapacityUnits=5
```

Now, if we run `list-tables` again, the output should contain
the table we just added.

```
{
    "TableNames": [
        "User"
    ]
}
```

## Conclusion

Setting up DynamoDB locally is a great way to develop and test your application without incurring AWS costs. You can use various storage options such as `-sharedDb`, `-inMemory`, or `-dbPath` depending on your development needs, and access the local instance through the AWS CLI or SDK.


This blog shows how to set up DynamoDB locally, and also demonstrates a few simple commands to access local DynamoDB.

DynamoDB

Use Lambda with Node.js to Insert Data Into DynamoDB

How to Backup DynamoDB Data to Different AWS Account

Backup AWS DynamoDB Table to Local

Move DynamoDB Table from Local to AWS Cloud

Create DynamoDB Table Locally

How to Setting up DynamoDB Locally