Forem: Rashi Agarwal

Deep dive into AWS Serverless Architecture

Rashi Agarwal — Tue, 31 Dec 2024 16:01:47 +0000

Serverless architecture is more than just a buzzword, it’s a revolution in how we build and scale applications. Imagine writing code without worrying about servers, infrastructure, or scaling. Sounds dreamy, right? But serverless isn’t magic—it’s a well-structured approach with distinct layers working together seamlessly.

Tiers of a Serverless Architecture

The most common serverless architecture pattern that we find almost everywhere, irrespective of whether we are using servers or going serverless. It is the three-tier Architecture, most common form of multi-tier architecture

The three-tier architecture, as the name suggests, has 3 tiers. Let’s dive into these tiers :

1. Database or Data Tier

No application is complete without data. The data layer ensures your application stores, retrieves, and processes information effectively.The data tier would contain the databases and you could also use other data stores as well. The data stores fall into two categories:
1️⃣ IAM enabled Data stores: IAM enabled data stores allow you to connect to them directly using the AWS APIs.
Core Services: Amazon DynamoDB, S3, and Amazon ElasticSearch.

2️⃣ VPC hosted Data stores: hese services run on hosted instances within a VPC. It allows you to connect to different databases using database credentials.
Core Services: Amazon RDS, Redshift, and ElastiCache.

Example => You could use Amazon RDS for PostgreSQL as your relational database and connect to it through your Serverless Lambda functions. This setup is perfect for applications that require complex queries, transactional consistency, or advanced analytics, such as an inventory management system that tracks stock levels, sales, and reorders in real time.

2. Serverless Logic Tier or Application Layer

This is where the core business logic of your serverless application would run.This layer processes user requests, runs workflows, and applies your application’s core logic.
Core Services:
1️⃣ AWS Lambda: Execute your code without provisioning servers.

2️⃣ Amazon API Gateway: Expose your backend logic through REST or WebSocket APIs.

3️⃣ AWS Step Functions: Orchestrate multiple workflows with visual diagrams and state machines.

Example => Let’s say you’re building a real-time translation app. When a user sends text, an API Gateway triggers a Lambda function that:
(i) Calls Amazon Translate for language conversion.
(ii) Stores the original and translated text in Amazon DynamoDB.
(iii) Sends a notification via Amazon SNS to the recipient.

This entire workflow can be orchestrated using Step Functions, ensuring each step runs smoothly or retries on failure.

3. Presentation Tier or Frontend

The presentation layer is where your users interact with your application. In serverless, this layer is often lightweight and scalable.The frontend would interact with the backend through the Logic tier.

Example => Frontend applications could use API Gateway endpoints or event triggers to call Lambda functions, which in turn interact with the data stores available in the Data Tier.
These frontend applications could be: static websites hosted in S3, Alexa, IOT devices, mobile app frontend.

Putting it Together

Let’s combine everything into a real-world application: a serverless static website hosted on S3.

Presentation Tier: The website’s HTML, CSS, and JavaScript files are hosted on Amazon S3 and distributed globally through Amazon CloudFront for low-latency access. The frontend includes a user-friendly interface that allows visitors to submit feedback. We can include services like AWS Cognito for authentication and authorization.
Logic Tier: When users submit feedback through the form, the request is sent to Amazon API Gateway, which triggers an AWS Lambda function. The Lambda function interacts with the data tier, processes the feedback, applies any business logic (e.g., spam filtering), and stores the data in the database.
Data Tier: Feedback submissions are stored in Amazon DynamoDB for fast and scalable access. For additional analytics, the data is periodically streamed to Amazon S3.
Below is the architecture diagram for the same:

That's all for the blog! Hope you liked it and learned something from it😄

Running lambdas locally using Javascript/Node.js

Rashi Agarwal — Sun, 29 Dec 2024 20:15:45 +0000

Tired of deploying to the cloud just to test your AWS Lambda? It’s like mailing yourself a letter just to proofread it—slow, expensive, and totally unnecessary.

What if you could invoke your Lambda locally—right from your JavaScript application? No cloud round-trips, no waiting, just instant feedback. With AWS SAM (Serverless Application Model) and a sprinkle of Node.JS/JavaScript, you can test and debug your Lambdas on your machine, saving time, money🤩.

Pre-Requisites:

I am using a Windows PC and have the following things set-up before proceeding ahead:

AWS SDK

aws --version

SAM CLI

sam --version

Docker

docker --version

Node.js

node --version

Let’s get started!

We will start by creating a demo application using init command and then further proceed to invoke lambda within the application code (Nodejs).

1> Navigate to the folder where you want to set up your project.

sam init --runtime nodejs

This will create a basic Hello world application.It has a simple Lambda handler which it takes in the event and returns back the data received from a particular URL, along with a Hello World message.

Let's take a deeper dive into what the files implement and how the code works:

SAM Template (template.js) -> it implements HelloWorld Function where it uses the Code URI property set to Hello World SLASH. This implies that the Lambda handler code is inside the Hello World folder.
- app.js -> This is referred in the Handler property of the SAM template, it contains exported function called Lambda Handler.

You will notice a dependency named 'axios' in package.json, note that the module is simply used to make HTTP requests to the given URL.

2> Install the dependency from package.json by navigating to the folder having the file, then use the command:

npm install

3> Now, start the Lambda service locally by running the command.

sam local start-lambda

So, now the local Lambda service is running on port 3001.

4> We will invoke our lambda functions from within our application code using the AWS SDK. To do that, let's create a sample node.js project. Create a new folder, navigate to the folder and enter the command.

npm init
npm install aws-sdk --save

5> Now create test.js file and reference the AWS SDK, configure the AWS region,instantiate a Lambda object.

const AWS = require('aws-sdk');
AWS.config.update({ region: 'us-west-2' });
const lambda = new AWS.Lambda({
      endpoint: 'http://127.0.0.1:3001'
});

var parameters = {
    FunctionName: 'HelloWorldFunction',
    PayLoad: new Buffer('{}')
};

lambda.invoke(params, (e,data) => {
  if(e){
    console.log("Error: "+e);
  } else{
      console.log(data);
  }
});

The parameter object here, invokes the Lambda Function, replace the function name according to the application code. The endpoint refers to the one on which your local lambda service is started.

6> Now run the command in a new terminal:

node test.js

7> Verification and Testing: When you navigate back to the AWS SAM powershell, you can see it invokes Lambda handler locally, by first loading the function in a Docker container and execute it with our input event data.
Now navigate back to the other terminal, you can see the response from the Lambda function, with status code 200 ✅, message Hello World, and the location IP address😄.

Wrapping Up

And there you have it—a faster, smarter way to test your AWS Lambda functions without ever leaving the comfort of your local setup. By invoking Lambdas locally with JavaScript and NodeJS, you’ve unlocked a whole new level of efficiency. Now you can iterate faster, debug smarter, and build cooler apps—all while keeping your cloud costs low.

Happy coding, and may your Lambdas always run as smoothly locally as they will in the cloud! 🎉

Seamless User Authentication: Integration of AWS Cognito with HTML/CSS and JavaScript

Rashi Agarwal — Sat, 23 Dec 2023 14:47:35 +0000

In the domain of web development, user authentication stands as a pivotal element ensuring application security and delivering a personalized user experience. AWS Cognito, a fully managed authentication service from AWS, simplifies the management of user identities and authentication processes. This blog post delves into the seamless integration of AWS Cognito with HTML, CSS, and JavaScript, enhancing the authentication journey within web applications.

Understanding AWS Cognito

Amazon Cognito offers a comprehensive solution for user identity management, allowing developers to handle user sign-up and sign-in, as well as manage user profiles and permissions. It supports various identity providers, including social identity providers such as Google and Facebook.

Key features of AWS Cognito include:

User Pools: User pools enable developers to create and manage a user directory where users can sign up, sign in, and manage their profiles.
Identity Pools: Identity pools (federated identities) allow users to obtain temporary AWS credentials to access AWS services.
Authentication: Supports multi-factor authentication (MFA) and various identity providers, providing flexibility in authentication methods.
Customizable UI: Developers can create a customized user interface for the authentication process.

Getting Started:

This demo will include creating a sign up/login page before accessing the website. The website is coded in HTML and javascript and we will be integrating AWS Cognito functionality in the sign up page.

STEP 1: Creating AWS Cognito user pool

For this follow the given steps:

Go to AWS Cognito console and choose Create User Pool.
In Provider types, choose Cognito user pool.
For the user sign-in options choose from the given options, suitable for your website sign up page.
Configure the options as per the requirement of the sign up page you are developing.
Now for the 5th step: Integrate your app: Enter the cognito pool name. Select the option Use the Cognito Hosted UI. Then select Use a cognito domain and enter the domain prefix, same as that of your user pool name.
For the initial app client, select public client and enter app client name.
It is important to add a callback URL, it's the URL that the user will be directed to once they have signed in.
For example: http://localhost:8000/home.html
Now review the steps, and click create user pool.
You will get the cognito URL copy it.

STEP 2: Integrating AWS Cognito API with HTML Login Page

We'll look at a sample snippet of login page code wherein we'll call the AWS Cognito API.


<!DOCTYPE html>
<html lang="en">
<head>
<title>LogiN Page Sample </title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">    
<link rel="icon" type="image/png" href="images/icons/favicon.ico"/>
<link rel="stylesheet" type="text/css" href="fonts/font-awesome-4.7.0/css/font-awesome.min.css">
<link rel="stylesheet" type="text/css" href="fonts/iconic/css/material-design-iconic-font.min.css">
<link rel="stylesheet" type="text/css" href="vendor/animate/animate.css">
<link rel="stylesheet" type="text/css" href="css/util.css">
<link rel="stylesheet" type="text/css" href="css/main.css">
</head>
<body>

    <div class="limiter">
        <div class="container-login100">
            <div class="wrap-login100">
                <form class="login100-form validate-form">
                    <span class="login100-form-title p-b-26">
                        Welcome to YourStyle
                    </span>

                    <div class="container-login100-form-btn">
                        <div class="wrap-login100-form-btn">
                            <div class="login100-form-bgbtn"></div>
                            <a class="<Insert AWS Cognito API>">
                            Login   </button>
                        </div>
                    </div>

                    <div class="text-center p-t-115">
                        <span class="txt1">
                            Don’t have an account?
                        </span>

                        <a class="txt2" href="<Insert AWS Cognito API>">
                            Sign Up
                        </a>
                    </div>
                </form>
            </div>
        </div>
    </div>


    <div id="dropDownSelect1"></div>

<script src="vendor/jquery/jquery-3.2.1.min.js"></script>
<script src="vendor/animsition/js/animsition.min.js"></script>
<script src="vendor/bootstrap/js/popper.js"></script>
<script src="vendor/bootstrap/js/bootstrap.min.js"></script>
<script src="vendor/select2/select2.min.js"></script>
<script src="vendor/daterangepicker/moment.min.js"></script>
<script src="vendor/daterangepicker/daterangepicker.js"></script>
<script src="vendor/countdowntime/countdowntime.js"></script>
<script src="js/main.js"></script>

</body>
</html>

Now the crucial part here is how to insert the AWS Cognito API which will make the correct calls and give the required functionality. To integrate it follow the given syntax:

https://<aws cognito url>/login?response_type=code&client_id=<fetch from the user pool created>&redirect_uri=<callback url that you entered while creating the pool>

Example would be:
https://homestyle.auth.us-east-1.amazoncognito.com/login?response_type=code&client_id=5icc2b3ks47a43hopdmbdoeqer&redirect_uri=http://localhost:8000/home.html

STEP 3: Creating YAML file for AWS Cognito
Name the YAML file in following way:
name_of_user_pool-cognito.yaml

Follow the given template syntax:

AWSTemplateFormatVersion: 2010-09-09 

Resources:
  UserPool:
    Type: AWS::Cognito::UserPool
    Properties:
      AutoVerifiedAttributes:
        - email
      UsernameAttributes:
        - email
      UserPoolName: !Sub app_pool1
      Schema:
        - AttributeDataType: String
          Mutable: true
          Name: name
          Required: true

  UserPoolClient:
    Type: AWS::Cognito::UserPoolClient
    Properties:
      AccessTokenValidity: 60 # (minutes) default value.
      AllowedOAuthFlowsUserPoolClient: true
      AllowedOAuthFlows:
        - code
        - implicit
      AllowedOAuthScopes:
        - aws.cognito.signin.user.admin
        - email

      CallbackURLs:
        - !Sub "http://localhost:8000/home.html"
      ClientName: !Sub homestyle
      EnableTokenRevocation: true # default value.
      ExplicitAuthFlows:
        - ALLOW_CUSTOM_AUTH
        - ALLOW_REFRESH_TOKEN_AUTH
        - ALLOW_USER_SRP_AUTH
      IdTokenValidity: 60 # (minutes) default value.
      PreventUserExistenceErrors: ENABLED # default value.
      RefreshTokenValidity: 30 # (days) default value.
      SupportedIdentityProviders:
        - COGNITO
      TokenValidityUnits:
        AccessToken: minutes
        IdToken: minutes
        RefreshToken: days
      UserPoolId: !Ref us-east-1_WD8wX51gU

  UserPoolDomain:
    Type: AWS::Cognito::UserPoolDomain
    Properties:
      Domain: !Ref https://homestyle.auth.us-east-1.amazoncognito.com
      UserPoolId: !Ref us-east-1_WD8wX51gU

From the above template, customize following fields:

Properties
UserPoolName
CallbackURLs
ClientName
UserPoolID
UserPoolDomain

In conclusion, integrating AWS Cognito with HTML, CSS, and JavaScript empowers developers to build secure and user-friendly authentication systems. With AWS Cognito's robust features and flexibility, you can tailor the authentication process to meet the specific requirements of your web application, providing a seamless and secure experience for your users. By following the steps outlined in this blog post, you can successfully integrate AWS Cognito and elevate the authentication standards of your web applications.

Tips to get accepted into AWS Community Builder Program

Rashi Agarwal — Mon, 29 May 2023 19:52:32 +0000

👉What is AWS Community Builder Program?

Since the beginning of my college life I always wanted to join some community where I could actually contribute and learn something. While joining college communities might still be helpful and fun, joining a global community is a whole new experience. The happiness of getting accepted in the community, the excitement of interacting with like-minded professionals from all across the globe and working together on projects, sharing thoughts, is unmatchable.
I have been exploring AWS for a while now and when I got to know that I could get the opportunity of being a part of its community, I knew I couldn't let it slip away.

Now you may want to know what's so different about this program that sets it apart from other communities? To answer your question, I'll start by talking about what the community builder program is centered around. Amazon Web Services (AWS) is a cloud platform featuring several services using which we can deploy our applications on cloud, utilizing additional features like Load Balancing, Auto Scaling, Security. AWS Community builder focuses on bringing together people who are AWS enthusiasts and are actively working towards learning about AWS, contributing to projects and sharing their knowledge by either speaking at events, writing blogs, etc.

👉Benefits:

There are several benefits to joining AWS Community Builder Program. First, I'll list the well known ones:

Getting AWS Promotional Credits worth $500💸
Opportunity to grow your network👥
Connect with subject matter experts👩‍🏫👨‍🏫
One year free subscription to Cloud Academy☁️
Receiving awesome swags as a welcome kit from the AWS Community Builder Team😍💃

There are certainly a lot of other benefits on joining the community. It doesn't matter in which category you are selected as a community builder, you can connect with other builders and get knowledge as well as contribute to other topics of your interest too. You can get discount vouchers to attend various AWS events like AWS re:Invent, AWS re:Inforce, AWS Summits. As a college student, I have been focusing on building my resume and thus also planning to give AWS Certification exams, the program also gives the opportunity to request for vouchers for the examination whenever we feel ready to take it.
As a community builder you get to attend several virtual events conducted by professionals in the specific field, trust me this helps a lot especially when you are working on some entirely new concept and building a project. You are given a new perspective and learn how to use the specific service, in a way which even Google cannot educate you about!
The list does not end here! You also get to participate in exclusive hackathons and competitions conducted for Community Builders, with prizes upto $9000!! Random giveaways of you participating in surveys, giving reviews on the services that you have used are also conducted. I have connected with so many great people, it is truly amazing to discuss and share your thoughts with individuals who will motivate you to grow further.

👉Application Process:

My background:
I am Cloud Computing Enthusiast, former project intern at TRAIVIS, UK. I am also AWS Cloud Practitioner certified, AWS Community Builder. My interest in research has led me to publish research papers in IEEE Conferences in Machine learning domain.

The applications to this program are opened twice a year and its accepts a limited amount of people every year.
It's important to know your interests before applying to the program as there are several categories to choose from, which the builder will be assigned once been accepted. The categories are:

Serverless
Storage
Containers
Machine Learning
Networking and Content Delivery
Arm Development
Data (Databases, Analytics, Blockchain)
Developer Tools
Game Tech
Mobile and Web Apps
Management, Governance and Migration
Security, Identity & Compliance

STEP 1. Apply using the link:
⭐ https://aws.amazon.com/developer/community/community-builders

STEP 2. Choose the category (3 based on priority) that you would like to apply from.

STEP 3. You will be prompted to write about why you are interested in the program. Be honest while sharing your story, keep in mind to include any certifications if done, as it might increase your chances of getting into the program.

STEP 4: Share your social media profiles.

STEP 5: Share links to your projects github repositories, technical blogs, events conducted.

STEP 6: Fill out the survey related to the activities that you have participated in past year.

Once you are accepted in the program, make sure to stay active by attending meetings, connecting with people, frequently checking the Slack workspace and sharing your knowledge by either writing blogs, conducting or speaking at events.

👉Tips for your application to get accepted:

I'll be completely honest in this section. These are some of the points that play a crucial role in your application process, in my opinion:

Having published one or preferably more than one technical write up on some platform is a necessity, if not a technical write up then maybe a video link of you speaking at some event about AWS. By technical write up I do not mean sharing your experience of how to clear a certain exam, but something that displays your knowledge of having worked on AWS services, Azure or GCP.
This is one of the most important requirement, don't be disheartened if this is something that you have not done yet. I encourage you to actively learn more about AWS and start sharing your knowledge.
Your cloud story (STEP 3), plays an important role too as it displays your perspective of participating in this community and your achievements and knowledge which could help to build a more diverse community. Please be honest while writing this answer.
Try to add some links of your completed projects which demonstrates use of cloud platform like AWS, GCP or Azure. It increases your chances of getting into the program.
Do mention your completed certification in Cloud, it can be Azure or GCP too. This might not be sufficient but helps in building a stronger application.

I hope this blogs help you out, to get into the AWS Community Builder program. If you do not get accepted in your first attempt, don't be disheartened, but work on building a stronger application and apply again.
For further questions or help do feel free to reach me out on:
https://www.linkedin.com/in/rashi-agarwal-93404b240/

If you'd like, follow me on github too😝. Here's the link:
https://github.com/rashi2911

DynamoDB using AWS SDK for Javascript/Node.js

Rashi Agarwal — Tue, 07 Mar 2023 05:28:47 +0000

What is DynamoDB?

Amazon DynamoDB is a fully managed NoSQL database service. It allows you to work with Big Data. It provides features like:

Seamless on-demand scaling.
Unlimited concurrent read/write operations.
Single-digit millisecond latency.
Microsecond latency with DAX ( caching service).
Fault tolerant, supports cross-region replication and highly scalable.
Can process largely unstructured data with high volume and frequency.
Pricing based on capacity you provision for each table.

DynamoDB must have a primary key.

Data Types in DynamoDB

Scalar Types : Represents exactly one value which can be string, numbers, binary, boolean or null.
Set Types : Represents multiple scalar values which can se string set, number set or binary set.
Document Types : It has complex structure with nested attributes which ca be map or list.

Pre-Requisites for using DynamoDB with AWS SDK in Node.js/ Javascript

Firstly make sure the aws-cli is installed in your system along with the aws environment variable and configurations set up. You can check this by simply running command: aws --version.

Go to terminal and run the instructions:

npm init
npm install aws-sdk — -save

Basic Table operations in DynamoDB using AWS SDK

Listing DynamoDB tables

//referencing sdk in js file
const AWS = require("aws-sdk");
//specifying aws region where dynamodb table will be created
AWS.config.update({ region: 'us-east-1' });
//instantiate dynamodb class
const dynamodb = new AWS.DynamoDB();
//listing tables
dynamodb.listTables({}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Describe Tables

dynamodb.describeTable({
     TableName: "demo_sdk"
 }, (err, data)=>{
     if(err) {
         console.log(err);
     } else {
         console.log(JSON.stringify(data, null, 2));// '2' is to beautify the output 
     }
 });

Create Table

Provisioned throughput here allows for predictable performance at scale. It is a major factor in pricing and is defined in read capacity units(RCUs) and write capacity units(WCUs).

1 capacity unit= 1 request per second

dynamodb.createTable({
    TableName: "demo_sdk",
    AttributeDefinitions: [
        {
            AttributeName: "id",
            AttributeType: "S" //string
        },
        {
            AttributeName: "timestamp",
            AttributeType: "N" //number
        }
    ],
    KeySchema: [
        {
            AttributeName: "id",
            KeyType: "HASH"
        },
        {
            AttributeName: "timestamp",
            KeyType: "RANGE"
        }
    ],
    ProvisionedThroughput: {
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

Update Table

//Changing read capacity units from 1 to 2 for the table
dynamodb.updateTable({
    TableName: "demo_sdk",
    ProvisionedThroughput: {
        ReadCapacityUnits: 2,
        WriteCapacityUnits: 1
    }
}, (err, data) => {
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

Delete table

dynamodb.deleteTable({
    TableName: "demo_sdk"
}, (err, data) => {
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

You can view the changes after each operations by using the describeTable function of dynamodb. All the changes will be reflected in the AWS Management console by writing just a few lines of code and without manually clicking and doing the tedious tasks.

If you go through the syntax for the code snippets carefully it’s quite simple isn’t it? So assuming that now you have got a bit of hold of using AWS SDK for dynamodb we’ll jump to a bit more of detailed table operations.

Earlier we used AWS.DynamoDB class which uses low-level programming approach. Now we’ll use another class of dynamodb which is AWS.DynamoDB.DocumentClient , provides us with high level access while working with items. We say it provides high level access because it abstracts all the unnecessary details from the user like mapping of the internal DynamoDB data types to the JavaScript data types.

High Level Access Table Operations

Put Item

The instantiation of the aws sdk and the aws region will remain the same as previous codes.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.put({
    TableName: 'demo_sdk',
    Item: {
// specify attributes as key value pairs
        user_id: 'first',
  //timestamp is the primary key
        timestamp: 3,
        title: 'The Secret',
        content: 'Book'
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Update Items

Want to update the item entry but don’t want to waste time searching and modifying it’s value? DynamoDB provides a solution for that too, which is the docClient.update function.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.update({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'first',
        timestamp: 3
    },
    UpdateExpression: 'set #old = :new',
    ExpressionAttributeNames: {
        '#old': 'The Secret' 
    },
    ExpressionAttributeValues: {
       //Title of item is updated
        ':new': "Hall of Games"
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Deleting Items

Once you start seeing the pattern in the syntax of the code it becomes fairly easy to write it on your own so try this one by yourself and then compare your code.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.delete({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'first',
        timestamp: 3
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Batch Write Items

This function helps us put or delete multiple items at once making our job much simpler when working with large set of table entries.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.batchWrite({
    RequestItems: {
        'demo_sdk': [
            {
              // deletes item , here, only one
                DeleteRequest: {
                    Key: {
                        user_id: 'first',
                        timestamp: 3
                    }
                }
            },
            {
              // inserting two items in the table
                PutRequest: {
                    Item: {
                        user_id: 'new',
                        timestamp: 1,
                        title: 'To Kill a MockingBird',
                        content: 'Harper Lee'
                    }
                }
            },
            {
                PutRequest: {
                    Item: {
                        user_id: 'two',
                        timestamp: 2,
                        title: 'Harry Potter',
                        content: 'J.K Rowling'
                    }
                }
            }
        ]
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Get an item

const docClient = new AWS.DynamoDB.DocumentClient();
// to get an item with the corresponding key parameters
docClient.get({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'two',
        timestamp: 2
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Query an item

const docClient = new AWS.DynamoDB.DocumentClient();
//here we specify th query condition or the where clause, for instance if we
// have multiple table entries for a user_id and want to get all those items at
//once (in this case we don't, but for the sake of learning XD)
docClient.query({
    TableName: 'demo_sdk',
// condition is: user_id must be equal to the value of expression attribute id
    KeyConditionExpression: "user_id = :id",
    ExpressionAttributeValues: {
        ":id": "new"
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Summary:

You have familiarized yourself with a basic understanding of what AWS DynamoDB is and then further learned how to work with dynamodb using simple javascript codes with AWS SDK. Further learned about the classes of dynamodb and the low level and high level table operations like: Create Table, Delete Table, Describe Table, Put item, Get item, Delete item, Batch Write item, Query an item and update the item.

References:

https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html

https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html

Thank you for reading!
Github Link: https://github.com/rashi2911/dynamo-db-aws-sdk