
<p>
  This blog show how to create AWS Lambda with Node.js and insert record into
  DynamoDB, also shows manully deploy Lambda as package to AWS from the your
  local develop environment.&nbsp; &nbsp;
</p>
<h2>Prequirement</h2>
<ul>
  <li>Have an AWS Account</li>
  <li>Setup AWS Cli Config</li>
  <li>Create AWS DynamoDB Table</li>
  <li>Install Node.js on Mac</li>
</ul>
<h2>Create AWS Role for Lambda to Access DynamoDB</h2>
<p>
  Here, we'll create new Lambda policy to access DynamoDB, go to the AWS Roles
  and click Create role.&nbsp;
</p>
<p>Choose Lambda service and click add permission.</p>
<p>
  At the attach permissions policies page, click create policy, you can use
  either the visual editor or JSON view, what we gonna do here, is providing the
  Lambda to have DynamoDB PutItem permission. Following are code snippet how it
  shows at the JSON view. As you can see, this policy is allow dynamodb PutItem
  operation because our code later will use PutItem to add record to
  DynamoDB.&nbsp;
</p>
<pre class="language-javascript"><code>{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "dynamodb:PutItem",
            "Resource": "*"
        }
    ]
}</code></pre>
<h2>Create Node.js code for Lambda</h2>
<p>
  Now, we'll back to our local develop environment and write some code. First
  we'll need to setup the node.js package file, you can run following command to
  create a default package file. This will create
  <code>package.json</code> file.
</p>
<h3>Create package.json file</h3>
<pre class="language-javascript"><code>npm init -y</code></pre>
<h3>Create Lambda node.js code</h3>
<p>Run this command to open command editor.</p>
<pre class="language-markup"><code>nano index.js</code></pre>
<p>
  At the command editor, paste following code and save the index.js file. This
  will be the file that we'll deploy Lambda later.&nbsp;
</p>
<p>
  Following is assume we already have table called
  <code>S3BucketImages</code>, you can either go to AWS Dynamodb to create the
  table and make sure the table's region match to your code. Set the Partition
  key as UniqueKey.&nbsp;
</p>
<pre class="language-javascript"><code>onst AWS = require('aws-sdk');
const dynamodbClient = new AWS.DynamoDB.DocumentClient();

exports.handler = (event, context, callback) =&gt; {

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

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

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

};</code></pre>
<h3>Parepare package to deploy to AWS Lambda</h3>
<p>
  Now, we'll start to prepare deployment file as zip file and will deploy to AWS
  as AWS Cli command line. The code we have only have dependency for
  <code>aws-sdk</code>, so let's install it, this will create node_modules on
  your local folder.
</p>
<pre class="language-javascript"><code>npm install aws-sdk</code></pre>
<p>
  Run this command at your terminal to include our index.js and node_module and
  create zip file.
</p>
<pre
  class="language-javascript"
><code>zip -r index.zip index.js node_modules</code></pre>
<p>
  We'll then run below command to create lambda function,&nbsp; you'll replace
  the AWS account id and the role created earlier.&nbsp;
</p>
<pre
  class="language-javascript"
><code>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}</code></pre>
<h3>Test Lambda function</h3>
<p>
  This should be pretty much everything you need to access DynamoDB from lambda,
  you can use the Test tab at the lambda, make sure it actually add new record
  into dynamodb.&nbsp;
</p>


This blog show how to create AWS Lambda with Node.js and insert record into DynamoDB, also shows manully deploy Lambda as packageto AWS from the your local develop environment.

Use Lambda with Node.js to Insert Data Into DynamoDB


<p>
  This blog shows how to migrate DynamoDB data between different AWS Account.
  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 different AWS account.
</p>
<p>
  Following is the process of handling migration from one AWS account to another
  account and the requirement.&nbsp;
</p>
<ul>
  <li>Have an AWS account, use as the source account.</li>
  <li>
    The source account has a DynamoDB table, and the bucket DynamoDB table will
    export to.
  </li>
  <li>
    Have an AWS account, use as the target account, and the bucket which source
    account will copy backup DynamoDB files into.
  </li>
</ul>
<h2>Exports DynamoDB Table to S3</h2>
<p>
  Here, we'll exports the DynamoDB table into the S3 bucket, login into AWS, and
  go to the DynamoDB section.
</p>
<h3>Enable point-in-time recovery</h3>
<p>
  Before backup the DynamoDB table to S3, you have to enable the PITR,
  point-in-time recovery. After enabling the PITR, click exports to S3, then
  choose the Source table you want to back up to the same account's S3.&nbsp;
</p>
<p>
  Enter the destination S3 bucket name and click the export button, now export
  should be starting and will copy all the backup files for the DynamoDB table
  into the S3 bucket. Note that, you can backup to different AWS account
  directly, but it's not covered on this blog.&nbsp;
</p>
<h3>Add Bucket Policy to Source Bucket</h3>
<p>
  After DynamoDB had backed up to the S3 Bucket, next you'll need to modify the
  Bucket Policy. Replace following <strong>ACCOUNT-B-ID</strong> to account B's
  id, replace <strong>ACCOUNT-B-USER</strong> to the account B's user which
  later will perform S3 file sync.
  <strong>ACCOUNT-A-Bucket-Name</strong> replaces the one that has DynamoDB
  backup content.
</p>
<pre class="language-markup"><code>{
    "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}" 
           ]
        }
    ]
}</code></pre>
<h2>Destination Bucket Setup</h2>
<h3>Setup Custom Policy</h3>
<p>
  For the destination bucket setup, we need to set up a user and has permission
  to perform bucket sync. Following policy just tell that we'll have access to
  both buckets.&nbsp;
</p>
<pre class="language-markup"><code>{
    "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}/*"
            ]
        }
    ]
}</code></pre>
<h3>Create a User and Attach the Policy</h3>
<h3>AWS Configure</h3>
<p>
  Here, you'll run AWS configure and add use the user who has the custom
  policy.&nbsp;&nbsp;
</p>
<h3>Execute the Command</h3>
<p>
  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.
</p>
<pre
  class="language-markup"
><code>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</code></pre>
<h3>Migrate Data from S3 to DynamoDB</h3>
<p>
  Now, the S3 bucket should have backup DynamoDB tables, there are a few ways
  you can do to handler ETL to migrate data into DynamoDB. You can use Glue Job
  to read the file from the S3 bucket and write them to the target DynamoDB
  table or use the write Lambda function to read the S3 file and write into the
  DynamoDB table. Following are a few ways possible to migrate data from S3 to
  DynamoDB, but it's not part of this blog.&nbsp;
</p>
<ul>
  <li>Write Glue Job</li>
  <li>Data Pipeline</li>
  <li>Write Lambda</li>
  <li>Use Amazon EMR&nbsp;</li>
</ul>
<p></p>
<p></p>


This blog shows how to migrate DynamoDB data between different AWS Account. You can migrate DynamoDB by using differentapproaches. 1. AWS S3 with AWS Glue. 2. Data Pipeline. 3. Amazon EMR, here, we'll use S3 and focus on how to move DynamoDB backupdata into different AWS account.

How to Backup DynamoDB Data to Different AWS Account


<p>
  This blog shows how to backup your AWS DynamoDB table (on the cloud) to your
  local DynamoDB environment. It could help in case you want to do a prototype
  but using production data.
</p>
<h3>Export table to S3</h3>
<p>
  In the first step, you need to login into AWS console's DynamoDB main page,
  choose the table then choose export to s3 bucket. At the moment I'm writing
  this, you'll need to set up the Point in time backup then you can export to
  S3. It says could charge, but once moved to s3 you can change it back.
</p>
<h3>Download data zip file</h3>
<p>
  Once DynamoDB export table to s3, you should be able to find your data under
  <strong>{your bucket}/AWSDynamoDB/{unique guid}/data</strong>, download the
  zip file to your OS.
</p>
<p>
  Following is the JSON file I download from the S3 bucket, noticed that no
  comma after each item object. Not sure why but you can just simply do
  replacement by adding a comma<strong>, </strong> after each item object.
</p>
<pre
  class="language-json"
><code>{"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"}}}</code></pre>
<h3>
  Use DynamoDB <code>put</code> or <code>BatchWriteItem</code> to import to
  local DynamoDB table
</h3>
<p>
  At the following, I'm loading the JSON file downloaded from the AWS DynamoDB
  table and add to my local DynamoDB port 8000's
  <strong>MyFakeFriend</strong> table.&nbsp;
</p>
<p>The following example is using node.js and running on Mac OS.</p>
<pre class="language-javascript"><code>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) =&gt; {
        if (err) throw err;
        let jsonData = JSON.parse(data);

        jsonData.Items.forEach(item =&gt; {

            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();
</code></pre>
<p>
  That's how so far I could you could move the table from AWS cloud to the local
  DynamoDB.
</p>


This blog shows how to backup your AWS DynamoDB table (on the cloud) to your local DynamoDB environment.

Backup AWS DynamoDB Table to Local


<p>
  This blog shows how to move DynamoDB local table and data to the DynamoDB Web
  Service, unlike SQL Database, you can use the backup file to restore to a
  different environment. So far at this moment, I'm writing, have not found out
  any other way to move Dynamo local to AWS Web service. So following sample
  code will just loop each item and use <code>aws-sdk</code> to put the request
  to the AWS DynamoDB web service.
</p>
<h3>DynamoDB table schema</h3>
<p>
  Following is the sample table schema, you can manually add the table on AWS
  Dynamo cloud or use SDK to create a table programmatically.
</p>
<pre class="language-javascript"><code>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
        }
    };
</code></pre>
<h3>Prepare the table data from local DynamoDB</h3>
<p>
  This command will scan the entire table <strong>MyFakeFriend</strong> and
  output the result to the <strong>data.json</strong> file.
</p>
<pre
  class="language-command"
><code>aws dynamodb scan --table-name MyFakeFriend --endpoint-url http://localhost:8000 &gt; data.json
</code></pre>
<h3>JSON data output</h3>
<p>
  Now, the following is the result when I run the JSON output command, so I have
  20 items need to add to the cloud Dynamo Service.
</p>
<pre class="language-json"><code>{
    "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
}
</code></pre>
<h3>Put request to add data</h3>
<p>
  Following is the sample code to loop through Dynamo local items and put the
  request to the cloud AWS Dynamo Service
</p>
<pre class="language-javascript"><code>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) =&gt; {
        if (err) throw err;
        let jsonData = JSON.parse(data);

        jsonData.Items.forEach(item =&gt; {

            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();

</code></pre>


This blog shows how to move DynamoDB local table and data to the DynamoDB Web Service, unlike SQL Database, you can use the backupfile to restore to a different environment.

Move DynamoDB Table from Local to AWS Cloud


<p>
  AWS DynamoDB is one of the AWS services for the NoSQL database on the cloud.
  You can create an AWS account then go to the AWS console's DynamoDB section to
  create a table and add items. On the SQL database, you or someone need to
  create a server for the SQL database, you then access the SQL database on that
  server by SQL query, but on the other hand, AWS will be managing the server
  for this NoSQL, serverless DynamoDB database. You can access it by the HTTP
  request.
</p>
<p>
  What about the local environment!? On the SQL side, you can set up the SQL
  database on your local, how about the DynamoDB? You can reference this blog
  for
  <a href="../blog/post/How-to-setting-up-DynamoDB-locally"
    >how to setup Dynamodb in your local environment</a
  >. This blog will show how to create a DynamoDB table in your local
  environment.
</p>
<p>
  The following example code was using Node.js running on Mac OS. npm version is
  <strong>6.12.0</strong>, node version is <strong>v12.13.0</strong>.
</p>
<p>
  Following code snippet assume you already set up local DynamoDB and is running
  by
  <a href="../blog/post/How-to-setting-up-DynamoDB-locally">this</a>.
</p>
<h3>Create a DynamoDB table - node.js</h3>
<p>
  Following code will require npm package <code>aws-sdk</code> to access
  DynamoDB by node.js.
</p>
<pre class="language-javascript"><code>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();
</code></pre>
<p>
  Save above code somewhere on your local environment, assume you save as
  <code>app.js</code>, <strong>cd</strong> to the folder directory then run
  command as following.
</p>
<pre class="language-javascript"><code>node app.js
</code></pre>
<p>If no error shows, you should be see following message from the response.</p>
<pre class="language-javascript"><code>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"
  }
}</code></pre>
<p>
  In the above example, I'm trying to create a DynamoDB table called
  <strong>MyFakeFriend</strong>, and set the <strong>name</strong> as the
  partition key, <strong>age</strong> as the sort key. One thing good for setup
  DynamoDB locally is that you can create prototype and test out the DynamoDB
  schema before ship to the actual AWS DynamoDB service in the cloud.
</p>
<p>
  There're lots of benefits to doing that, for example once create a table in
  AWS DynamoDB service in the cloud you can't change the primary key, the
  partition, sort key, and local secondary index. Looks like it is what it is
  from the AWS at the moment I'm writing this blog, around 2020. It could change
  who knows.
</p>
<h3>Adding data to a DynamoDB table - node.js</h3>
<p>
  After create a table to DynamoDB table, following example node.js code shows
  how to add random data to the this table.
</p>
<p>
  Assume you create following code as, <code>addData.js</code>. run
  <code>node addData.js</code> from the command window. This code will generate
  20 items to the table <strong>MyFakeFriend</strong> table. You could modify
  the max item from 20 to the number you want, for instance; adding ten of
  thousand data so you can do testing on the local environment before move to
  the AWS cloud.
</p>
<pre class="language-javascript"><code>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 &lt; 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();
</code></pre>
<h3>Test result by run scan the entire table</h3>
<p>
  To test the result and make it simple, you can run the following command to
  scan the result from the table.
</p>
<pre
  class="language-command"
><code>aws dynamodb scan --table-name MyFakeFriend --endpoint-url http://localhost:8000 </code></pre>


This blog will show how to create a DynamoDB table in your local environment.

Create DynamoDB Table Locally


<p>
  AWS DynamoDB is a document database that provides single-digit millisecond
  performance, it is a serverless database, which means you can focus on use
  applications to access the DynamoDB and AWS will manage the server for you.
  It's also available in multiple AWS regions and has built-in Cache DAX.&nbsp;
</p>
<p>
  Another good reason to use DynamoDB is the free tier provided by DynamoDB. up
  to 25 GB storage, 25 write capacity units, and 25 read capacity units are
  free. Compare to MongoDB, depend on the MongoDB cloud provider it might be
  500MB storage if you try to look for a free tier.&nbsp;
</p>
<p>
  Now, in this blog I'll show how to set up DynamoDB locally, also show a few
  simple codes to access local DynamoDB.
</p>
<h3>Download DynamoDB</h3>
<p>
  Go to this link from AWS to download DynamoDB, the different region has
  different DynamoDB file, so choose the region you'll be using for DynamoDB.
  After unzipping the file, run the following command.
</p>
<p>
  <a
    href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html"
    target="_blank"
    rel="noopener"
    >Link to Download DynamoDB</a
  >
</p>
<h3>JRE</h3>
<p>
  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.
</p>
<p>
  <a href="https://www.java.com/en/download/" taget="_blank">Download JRE</a>
</p>
<h3>Start DynamoDB</h3>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
</code></pre>
<p>
  If you see the following means your DynamoDB is able to run at your local with
  port 8000.
</p>
<pre
  class="language-command"
><code>Initializing DynamoDB Local with the following configuration:
Port:	8000
InMemory:	false
DbPath:	null
SharedDb:	true
shouldDelayTransientStatuses:	false
CorsParams:	*
</code></pre>
<p>
  After download, the Dynamodb file to your local OS, <strong>cd</strong> to the
  folder, and run the following then it should start DynamoDB on your local.
  DynamoDB has a few ways to store the database file on your local, these are
  <strong>-sharedDb</strong>, <strong>-inMemory</strong> and
  <strong>-dbPath</strong>. Let's see what are the difference between these
  three.
</p>
<h4>Omit database file option</h4>
<p>
  If you omit any option, Dynamodb will store the database file with your AWS
  access key id with the region. For instance, you should see a DB file format
  as this <strong>{your AWS access key ID}_{region}.db</strong> when running the
  following command. So this file will change if you use a different AWS user by
  run the <strong>aws configure</strong>
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar
</code></pre>
<p>
  Use <strong>-sharedDb</strong>, will create a Dynamodb file
  <strong>shared-local-instance.db</strong> when starting the Dynamodb.
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
</code></pre>
<p>
  Now, there's another way to save Dynamodb file locally by use
  <strong>-dbPath {path} </strong>. For example, you have the following command,
  <code>-dbPath test2</code>, assume <code>test2</code> is a folder, first make
  sure the folder exists, then when you run the following command you'll see the
  <strong>shared-local-instance.db</strong> file at the
  <code>test2</code> folder.
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -dbPath test2
</code></pre>
<p>
  Use <strong>-inMemory</strong>, as the name show it will save the database
  file on the OS' memory but will destroy once stop the Dynamodb on your local.
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -inMemory
</code></pre>
<p>
  So which is better? that'll depend on what your use for DynamoDB on your
  local, if you just want to test something quick you don't care where it store,
  then you can omit the file option or use
  <strong>-inMemory</strong> by destroying the file once you have done your
  task. Or you can use <strong>-dbPath</strong> to create a file path. e.g. dev
  or dev2 to store different DynamoDB files for a different environment.
</p>
<h4>DynamoDB port Option</h4>
<p>
  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
  <strong>-dbPath</strong> with <strong>-port</strong>, cause you might have
  huge data to test on local before a move to the AWS DynamoDB service.
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb -port 8001
</code></pre>
<p>Furthermore, type help to get all the command options</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_b -jar DynamoDBLocal.jar -help
</code></pre>
<p>This is the output when running the -help option</p>
<pre
  class="language-command"
><code>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)</code></pre>
<h3>Run DynamoDB command in background</h3>
<p>
  You can also run your DynamoDB command in background by append
  <strong>$</strong> as follow. After this command, you type
  <code>ctrl + c</code>, you close the command but the DynamoDB will still run
  the background.
</p>
<pre
  class="language-command"
><code>java -Djava.library.path=./DynamoDBLocal_lib -jar DynoDBLocal.jar &amp;
</code></pre>
<p>
  If you wish to switch to the foreground of the DynamoDB command, add
  <strong>fg</strong> to the DynamoDB start command. That will bring the to the
  foreground, then you can do <code>ctrl + c</code> to actual close if you wish
  to stop the DynamoDB on your local.
</p>
<pre
  class="language-command"
><code>fg java -Djava.library.path=./DynamoDBLocal_lib -jar DynoDBLocal.jar
</code></pre>
<h3>Use AWS CLI</h3>
<p>
  Once the DynamoDB is ready, you can access DynamoDB via AWS CLI. You can try
  the list table, query, or update the table. However, before that, you will
  need to run <code>aws configure</code> to connect from your local OS to AWS
  service.
</p>
<h4>
  Create a User at AWS console and make sure the user can access the DynamoDB
</h4>
<p>
  There are many ways to achieve this and one way you can do is, create a group
  that has access to DynamoDB, then create a new user and assign the group to
  this user.
</p>
<p>
  Once you run the following command at your command-line tool, type the user's
  AWS access key ID and secret access key, then from your local OS will use that
  user's credential to access to AWS service.
</p>
<pre class="language-command"><code>aws configure
</code></pre>
<h3>Access to local DynamoDB</h3>
<p>
  Now, you should be able to access local DynamoDB from AWS CLI, let's try the
  following command which will try to list all the tables.
</p>
<pre
  class="language-command"
><code>aws dynamodb list-tables --endpoint-url http://localhost:8000
</code></pre>
<p>
  If you see the following output, means you are able to access your local
  DynamoDB now.
</p>
<pre class="language-command"><code>{
    "TableNames": []
}</code></pre>
<p>Let's try more, create a table for local Dynamodb.</p>
<pre class="language-shell"><code>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</code></pre>
<p>
  Now, if we run <code>list-tables</code> again, should see the output contains
  the table we just add.
</p>
<pre class="language-shell"><code>{
    "TableNames": [
        "User"
    ]
}</code></pre>


This blog I'll show how to set up DynamoDB locally, also show a few simple codes to access local DynamoDB.

Category 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