DEV Community: Jimmy

Utilize AI-powered Tools Amazon CodeWhisperer and Amazon Q in Visual Studio Code on Android Devices

Jimmy — Tue, 23 Jan 2024 21:08:36 +0000

While traveling, it can be challenging to carry a laptop everywhere, especially if you want to do some coding or testing. What if we could work solely using our mobile devices, particularly Android devices to run Visual Studio Code, and have AI-powered tools to assist in coding tasks?

In this article, we will explore how we can utilize AI-powered tools Amazon CodeWhisperer and Amazon Q in Visual Studio Code on Android Devices.

Amazon CodeWhisperer

CodeWhisperer is an AI-powered productivity tool that generates real-time, single-line, or full-function code suggestions in your integrated development environment (IDE) and in the command line to help you quickly build software. With CodeWhisperer, you can write a comment in natural language that outlines a specific task in English, such as, “Upload a file with server-side encryption.” Based on this information, CodeWhisperer recommends one or more code snippets directly in the IDE that can accomplish the task. You can quickly and easily accept the top suggestion (tab key), view more suggestions (arrow keys), or continue writing your own code. You should always review a code suggestion before accepting it, and you might need to edit it to ensure that it does exactly what you intended.

Amazon Q

Amazon Q is a new type of generative AI–powered assistant. It is specifically for work and can be tailored to your business to have conversations, solve problems, generate content, and take action using the data and expertise found in your company's information repositories, code bases, and enterprise systems. Amazon Q provides quick, relevant, and actionable information and advice to help streamline tasks, speed decision-making and problem-solving, and help spark creativity and innovation at work.

Termux

Termux is an open-source terminal emulator for Android that also acts as a Linux-like environment. It provides a Linux-like terminal on Android devices, allowing users to run a wide range of Linux tools and utilities directly on their smartphones or tablets. Termux is designed to bring a powerful and flexible Linux command-line experience to Android users.

Install and Configure Termux

Download Termux latest version.
After the download is complete, Install Termux by enabling Install unknown apps in Chrome.

Code Server (VS Code in the browser)

Code Server is an open-source project that allows you to run Visual Studio Code (VS Code) in a remote server environment, accessible through a web browser. VS Code is a popular source code editor developed by Microsoft, known for its lightweight and extensible nature.

With Code Server, you can set up an instance of VS Code on a remote server or cloud environment and then access it from your local machine through a web browser. This enables you to develop and edit code on a powerful server while using a more lightweight device for the actual editing and visualization.

Install Code Server

Run Termux, first run pkg update

Then run pkg install tur-repo

Then run pkg install code-server to install the Code Server.

Run Code Server

Run this command code-server --auth none in Termux

While keeping the Termux running, go to your browser (chrome) then type localhost:8080, you will then get directed to Visual Studio Code IDE.

AWS Toolkit for Visual Studio Code

The AWS Toolkit for Visual Studio is an extension for Microsoft Visual Studio running on Microsoft Windows that makes it easier for developers to develop, debug, and deploy .NET applications using Amazon Web Services. With the AWS Toolkit for Visual Studio, you'll be able to get started faster and be more productive when building AWS applications.

The AWS Toolkit for Visual Studio is available via the Visual Studio Marketplace and supports Visual Studio 2022, 2019, and 2017. The AWS Toolkit for 2013 and 2015 is contained in the AWS SDK and Tools for .NET install package.

Install AWS Toolkit

Go to Extension, then search for aws toolkit

Click Install

Sometimes, Installing the extension can fail, so you need to install the extension manually. You can follow the instructions provided by Visual Studio Code.

Authenticating AWS Toolkit extension

Connect with AWS

Proceed to Browser.

Confirm the Authorization request and continue.

After that, you need to log in with your AWS Builder account, and if you don't have one, you can create one.
Allow AWS Toolkit for VSCode.

If successful, you will then see Amazon Q and AWS Toolkit extensions appear in the bottom left sidebar on your VSCode. And you can start using it.

Using Amazon Q

To start using Amazon Q you can just start typing the question you want to ask and Amazon Q will answer it for you, like this.

Using Amazon CodeWhisperer.

To start using Amazon CodeWhisperer you can create a javascript file and then start creating a function. CodeWhisperer will generate the complete function for you like this.

Add Code Server as an Application

You can install your Code Server on your Android device by clicking this menu.

If successful, you can then run your Code Server fullscreen like other Native Android applications.

Conclusions

In conclusion, the integration of Code Server along with AI-powered tools like Amazon Q and Amazon CodeWhisperer enables us to seamlessly engage in coding activities directly from our Android devices. This innovative combination not only enhances flexibility during travel but also provides a powerful and efficient coding environment.

Check out my other post

Stream Amazon Bedrock Response with AWS Lambda Response Streaming

Jimmy for AWS Community Builders ・ Nov 24 '23

#aws #serverless #javascript #ai

Stream Amazon Bedrock Response with AWS Lambda Response Streaming

Jimmy — Fri, 24 Nov 2023 01:44:25 +0000

AWS Lambda support for response payload streaming. Response streaming is a new invocation pattern that lets functions progressively stream response payloads back to clients.

In traditional request-response models, the response needs to be fully generated and buffered before it is returned to the client. This can delay the time to first byte (TTFB) performance while the client waits for the response to be generated.

You can use Lambda response payload streaming to send response data to callers as it becomes available. This can improve performance for web and mobile applications. Response streaming also allows you to build functions that return larger payloads and perform long-running operations while reporting incremental progress.

In this article, we will explore how to create a lambda function URL with response streaming that can stream Amazon Bedrock response like this.

In the above demo, we are invoking Lambda function URL with a prompt payload,then our Lambda will invoke Amazon Bedrock model with response stream then Lambda will return the response in a stream.

The architecture will look like this

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

AWS Lambda

Amazon Web Services (AWS) Lambda is a serverless computing service provided by Amazon as part of its cloud computing platform. Serverless computing allows you to run code without provisioning or managing servers, which means you can focus on writing your application code without the need to worry about infrastructure.

Amazon Bedrock

Amazon Bedrock is a fully managed service that makes it easy to build and scale generative AI applications. It offers a choice of high-performing foundation models from leading AI companies, along with a broad set of capabilities that you need to build generative AI applications, simplifying development while maintaining privacy and security.

Prerequisites

AWS Serverless Application Model (SAM): AWS Serverless Application Model (AWS SAM) is an open-source framework that simplifies serverless application development and deployment on Amazon Web Services (AWS). To install AWS SAM you can refer to this documentation.
AWS Command Line Interface (CLI): AWS Command Line Interface (AWS CLI) is an open-source tool that enables you to manage AWS services from the command line. It provides a unified interface for interacting with AWS services, allowing you to control multiple AWS services from a single tool. The AWS CLI is available for Windows, macOS, and Linux operating systems. To install and configure AWS CLI you can refer to this documentation
Amazon Bedrock Model Access: To use Amazon Bedrock Model, make sure you already request access to the model that we are going to use which is Anthropic Claude model via AWS management console region N. Virginia us-east-1.

Create AWS SAM project

You can start creating an AWS SAM project by running the following command in your terminal

sam init --name lambda-bedrock --runtime nodejs18.x

Then choose 1 - AWS Quick Start Templates.

Which template source would you like to use?
        1 - AWS Quick Start Templates
        2 - Custom Template Location
Choice: 1

Next, choose 10 - Lambda Response Streaming.

Choose an AWS Quick Start application template
        1 - Hello World Example
        2 - GraphQLApi Hello World Example
        3 - Hello World Example with Powertools for AWS Lambda
        4 - Multi-step workflow
        5 - Standalone function
        6 - Scheduled task
        7 - Data processing
        8 - Serverless API
        9 - Full Stack
        10 - Lambda Response Streaming
Template: 10

Choose N to enable X-Ray tracing

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: N

Choose N to enable monitoring using CloudWatch Application Insights

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: N

SAM will then start creating your project

Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)

    -----------------------
    Generating application:
    -----------------------
    Name: lambda-bedrock
    Runtime: nodejs18.x
    Architectures: x86_64
    Dependency Manager: npm
    Application Template: response-streaming
    Output Directory: .
    Configuration file: lambda-bedrock\samconfig.toml

    Next steps can be found in the README file at lambda-berdrock\README.md

Our project folder structure will look like this

.
|-- README.md
|-- __tests__
|   `-- unit
|-- package.json
|-- samconfig.toml
|-- src
|   `-- index.js
`-- template.yaml

There are several files we need to modify like src\index.js where our function handler logic will be, and template.yaml which is our AWS SAM template.

Lambda Function Handler

Go to src\index.js.
Modify our index.js handler into this

const {
  BedrockRuntimeClient,
  InvokeModelWithResponseStreamCommand,
} = require("@aws-sdk/client-bedrock-runtime"); 

const bedrock = new BedrockRuntimeClient({ region: "us-east-1" });

exports.handler = awslambda.streamifyResponse(
  async (event, responseStream, context) => {
    const { prompt } = JSON.parse(event.body);

    const params = {
      modelId: "anthropic.claude-v2",
      contentType: "application/json",
      accept: "*/*",
      body: JSON.stringify({
        prompt: `\n\nHuman: ${prompt} \n\nAssistant:`,
        max_tokens_to_sample: 2048,
        temperature: 0.5,
        top_k: 250,
        top_p: 0.5,
        stop_sequences: ["\n\nHuman:"],
        anthropic_version: "bedrock-2023-05-31",
      }),
    };

    console.log(params);

    const command = new InvokeModelWithResponseStreamCommand(params);

    const response = await bedrock.send(command);
    const chunks = [];

    for await (const chunk of response.body) {
      const parsed = JSON.parse(
        Buffer.from(chunk.chunk.bytes, "base64").toString("utf-8")
      );
      chunks.push(parsed.completion);
      responseStream.write(parsed.completion);
    }

    console.log(chunks.join(""));
    responseStream.end();
  }
);

This is where we define the Claude model params

const params = {
      modelId: "anthropic.claude-v2",
      contentType: "application/json",
      accept: "*/*",
      body: JSON.stringify({
        prompt: `\n\nHuman: ${prompt} \n\nAssistant:`,
        max_tokens_to_sample: 2048,
        temperature: 0.5,
        top_k: 250,
        top_p: 0.5,
        stop_sequences: ["\n\nHuman:"],
        anthropic_version: "bedrock-2023-05-31",
      }),
    };

Then invoke Bedrock model with response stream.

const command = new InvokeModelWithResponseStreamCommand(params);

Then send the response back in chunks to client

 for await (const chunk of response.body) {
      const parsed = JSON.parse(
        Buffer.from(chunk.chunk.bytes, "base64").toString("utf-8")
      );
      chunks.push(parsed.completion);
      responseStream.write(parsed.completion);
    }

SAM Template

Next we will modify our SAM template template.yaml into this :

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: lambda-bedrock template

Resources:
  BedrockFunction:
    Type: AWS::Serverless::Function
    Region: us-east-1
    Properties:
      CodeUri: src/
      Handler: index.handler
      Runtime: nodejs18.x
      Timeout: 30
      FunctionUrlConfig:
        AuthType: NONE
        InvokeMode: RESPONSE_STREAM
        Cors:
          AllowMethods:
            - POST
          AllowHeaders:
            - "*"
          AllowOrigins:
            - "*"
      Policies:
        - Statement:
            - Effect: Allow
              Action: bedrock:InvokeModelWithResponseStream
              Resource: "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-v2"

Outputs:
  FunctionUrlEndpoint:
    Description: "Lambda Bedrock URL Endpoint"
    Value:
      Fn::GetAtt: BedrockFunctionUrl.FunctionUrl

In this template we will create a BedrockFunction with Nodejs runtime nodejs18.x

BedrockFunction:
    Type: AWS::Serverless::Function
    Region: us-east-1
    Properties:
      CodeUri: src/
      Handler: index.handler
      Runtime: nodejs18.x
      Timeout: 30

Then our the lambda function will have function url enabled with RESPONSE_STREAM invoke mode.

FunctionUrlConfig:
        AuthType: NONE
        InvokeMode: RESPONSE_STREAM

Finally we will output our Lambda function URL

Outputs:
  FunctionUrlEndpoint:
    Description: "Lambda Bedrock URL Endpoint"
    Value:
      Fn::GetAtt: BedrockFunctionUrl.FunctionUrl

Deploy AWS SAM project

Before we can deploy our SAM project, we need to run the build command like this

sam build

It will return this output

Starting Build use cache
Manifest is not changed for (BedrockFunction), running incremental build
Building codeuri: D:\lambda-bedrock\src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: BedrockFunction
 Running NodejsNpmBuilder:NpmPack
 Running NodejsNpmBuilder:CopyNpmrcAndLockfile
 Running NodejsNpmBuilder:CopySource
 Running NodejsNpmBuilder:CopySource
 Running NodejsNpmBuilder:CleanUpNpmrc
 Running NodejsNpmBuilder:LockfileCleanUp
 Running NodejsNpmBuilder:LockfileCleanUp

Build Succeeded

Built Artifacts  : .aws-sam\build
Built Template   : .aws-sam\build\template.yaml

Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided

Next, to deploy it for the first time we can run this command

sam deploy --guided --region us-east-1

Then you can configure your SAM deployment like this

Configuring SAM deploy
======================

        Looking for config file [samconfig.toml] :  Found
        Reading default arguments  :  Success

        Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [lambda-bedrock]: 
        AWS Region [us-east-1]: 
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [Y/n]: 
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]: 
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]: 
        BedrockFunction Function Url has no authentication. Is this okay? [y/N]: y
        Save arguments to configuration file [Y/n]: y
        SAM configuration file [samconfig.toml]: 
        SAM configuration environment [default]:

Then SAM will start provisioning your defined resources like this

Initiating deployment
=====================

File with same data already exists at lambda-bedrock/bbf3c1abca051b90e7660be4b7b51222.template, skipping upload


Waiting for changeset to be created..

CloudFormation stack changeset
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
Operation                               LogicalResourceId                       ResourceType                            Replacement
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
+ Add                                   BedrockFunctionRole                     AWS::IAM::Role                          N/A
+ Add                                   BedrockFunctionUrlPublicPermissions     AWS::Lambda::Permission                 N/A
+ Add                                   BedrockFunctionUrl                      AWS::Lambda::Url                        N/A
+ Add                                   BedrockFunction                         AWS::Lambda::Function                   N/A
-------------------------------------------------------------------------------------------------------------------------------------------------------------   


Changeset created successfully. arn:aws:cloudformation:us-east-1:319450934564:changeSet/samcli-deploy1700755410/ae1f9cd1-ec0c-4aee-91cb-1feac84e9b5e


Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y

2023-11-23 23:03:48 - Waiting for stack create/update to complete

CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
ResourceStatus                          ResourceType                            LogicalResourceId                       ResourceStatusReason
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
CREATE_IN_PROGRESS                      AWS::CloudFormation::Stack              lambda-bedrock                          User Initiated
CREATE_IN_PROGRESS                      AWS::IAM::Role                          BedrockFunctionRole                     -
CREATE_IN_PROGRESS                      AWS::IAM::Role                          BedrockFunctionRole                     Resource creation Initiated
CREATE_COMPLETE                         AWS::IAM::Role                          BedrockFunctionRole                     -
CREATE_IN_PROGRESS                      AWS::Lambda::Function                   BedrockFunction                         -
CREATE_IN_PROGRESS                      AWS::Lambda::Function                   BedrockFunction                         Resource creation Initiated
CREATE_COMPLETE                         AWS::Lambda::Function                   BedrockFunction                         -
CREATE_IN_PROGRESS                      AWS::Lambda::Url                        BedrockFunctionUrl                      -
CREATE_IN_PROGRESS                      AWS::Lambda::Permission                 BedrockFunctionUrlPublicPermissions     -
CREATE_IN_PROGRESS                      AWS::Lambda::Permission                 BedrockFunctionUrlPublicPermissions     Resource creation Initiated
CREATE_IN_PROGRESS                      AWS::Lambda::Url                        BedrockFunctionUrl                      Resource creation Initiated
CREATE_COMPLETE                         AWS::Lambda::Permission                 BedrockFunctionUrlPublicPermissions     -
CREATE_COMPLETE                         AWS::Lambda::Url                        BedrockFunctionUrl                      -
CREATE_COMPLETE                         AWS::CloudFormation::Stack              lambda-bedrock                          -
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Finally SAM will output our function URL endpoint like this

CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
Outputs
-------------------------------------------------------------------------------------------------------------------------------------------------------------   
Key                 FunctionUrlEndpoint
Description         Lambda Bedrock URL Endpoint
Value               https://mxtyk5msee54ddynby4h6wvkt40xoyab.lambda-url.us-east-1.on.aws/
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Take notice on the URL output https://mxtyk5msee54ddynby4h6wvkt40xoyab.lambda-url.us-east-1.on.aws/ that we are going to use to test.

Test

To test our Lambda endpoint we can run this following command in our terminal like this

curl -k \
-X POST \
-H 'Content-Type: application/json' \
-d '{"prompt":"what is serverless"}' \
https://mxtyk5msee54ddynby4h6wvkt40xoyab.lambda-url.us-east-1.on.aws/

The result will looks like this

[BONUS] Stream Response to Browser

To stream response to browser you can create a HTML page and use this following script

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Send Data to Server</title>
  </head>
  <body>
    <div>
      <label for="dataInput">Enter data:</label>
      <input type="text" id="dataInput" />
      <button onclick="sendData()">Send Data</button>
      <div id="streamed-data"></div>
    </div>

    <script>
      function sendData() {
        const dataInput = document.getElementById("dataInput");
        const inputData = dataInput.value;
        const streamedData = document.getElementById("streamed-data");
        streamedData.innerHTML = "";
        fetch(
          "https://mxtyk5msee54ddynby4h6wvkt40xoyab.lambda-url.us-east-1.on.aws/",
          {
            method: "POST",
            headers: {
              "Content-Type": "application/json",
            },
            body: JSON.stringify({ prompt: inputData }),
          }
        )
          .then((response) => {
            const reader = response.body.getReader();

            // Read data from the stream
            const readData = () => {
              return reader.read().then(({ done, value }) => {
                if (done) {
                  console.log("Stream complete");
                } else {
                  streamedData.innerHTML += `${new TextDecoder()
                    .decode(value)
                    .replace(/\n/g, "<br>")}`;
                  // Continue reading data
                  return readData();
                }
              });
            };

            // Start reading data from the stream
            return readData();
          })
          .catch((error) => console.error("Error:", error));
      }
    </script>
  </body>
</html>

The above script will allow us to stream response into browser like this

Cleanup

To delete all your resources you can run this command

sam delete --region us-east-1

Conclusions

As you can see, with above configuration our Lambda can return the response from Amazon Bedrock in stream mode instead of buffering the response first. This can improve performance for web and mobile applications.

Response streaming currently supports the Node.js 14.x and subsequent managed runtimes. You can also implement response streaming using custom runtimes. You can progressively stream response payloads through Lambda function URLs, including as an Amazon CloudFront origin, along with using the AWS SDK or using Lambda’s invoke API. You can not use Amazon API Gateway and Application Load Balancer to progressively stream response payloads, but you can use the functionality to return larger payloads with API Gateway.

Check out my previous post

Local Serverless Application Development with AWS SAM and Localstack

Jimmy for AWS Community Builders ・ Oct 18 '23

References

Serverless Scheduled Reporting Service with AWS EventBridge, Lambda, SNS, and CDK

Jimmy — Thu, 09 Nov 2023 17:39:56 +0000

Have you ever thought of building a simple scheduled reporting service without the need to manage a server and only pay per use (which in our case only runs 30 times a month)?

This scheduling service will send a daily total sales report to your email like this.

So in this article, we will learn how to build those services by utilizing several AWS services like Amazon EventBridge, AWS Lambda, Amazon SNS and deploy it with AWS CDK.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

EventBridge (CloudWatch Events)

EventBridge (CloudWatch Events) is a serverless event bus that makes it easy to connect your applications and services to data sources and other AWS services. It enables you to build event-driven architectures that respond automatically to state changes in your AWS resources.

EventBridge provides a unified view of all your events, regardless of where they originate. You can create rules to match events and route them to targets such as AWS Lambda functions, Amazon Kinesis streams, and Amazon Simple Notification Service (SNS) topics. This allows you to automate your workflows and respond to events in real-time.

AWS Lambda

AWS Lambda is a serverless computing service offered by Amazon Web Services (AWS). It allows developers to run code without provisioning or managing servers, as the underlying infrastructure is managed by AWS. With Lambda, developers can focus solely on writing and deploying their code, without worrying about scaling, capacity planning, or server management.

Lambda functions can be triggered by various events, such as changes to an S3 bucket, an HTTP request, or a message from an Amazon Kinesis stream. Once triggered, the function executes in a sandboxed environment, which runs on top of Amazon Elastic Container Service (ECS) containers. This environment provides isolation between functions and ensures that they do not interfere with each other.

Amazon Simple Notification Service (SNS)

Amazon Simple Notification Service (SNS) is a fully managed messaging service provided by Amazon Web Services (AWS). It enables developers to send individual messages or large-scale notifications to multiple subscribers or clients, such as mobile devices, email addresses, and HTTP endpoints.

With SNS, developers can fan out messages to a large number of recipients without having to worry about the underlying infrastructure, scaling, or delivery guarantees. The service takes care of distributing messages to the specified subscribers, handling duplication, throttling, and deliverability.

AWS Cloud Development Kit (CDK)

AWS CDK (Cloud Development Kit) is an open-source software development framework created by Amazon Web Services (AWS). It allows developers to define cloud infrastructure and applications in code, rather than manually configuring them through the AWS Management Console or CLI.

CDK provides a programmatic way to define infrastructure using familiar programming languages like TypeScript, JavaScript, Python, and Java. It offers a set of libraries and constructs that enable developers to describe the desired state of their infrastructure, and then provisions and manages it automatically.

Prerequisites

Create Project
Create Lambda handler
Create Stack
Import modules
Create Parameter
Create SNS Topic
Create Lambda Function
Permission to publish a message to SNS Topic
Create EventBridge Schedule Rule
Trigger Lambda from EventBridge
Complete Stack Code
Deploy Stack
Testing
Conclusion

Create Project

We will start by creating a folder.

mkdir cdk-scheduled-reporting && cd cdk-scheduled-reporting

Then initialize our CDK project

cdk init app --language javascript

Create Lambda handler

We will create our Lambda handler with the logic to collect the sales data and send it to Amazon SNS.

Create src folder
Create index.js inside src folder

touch src/index.js

We will simulate our sales data by getting dummy cart data from https://dummyjson.com/carts REST API server.
So, start typing the following code into src/index.js

const AWS = require("aws-sdk");
const sns = new AWS.SNS({ apiVersion: "2010-03-31" });

exports.handler = async (event) => {
  try {
    const data = await sns
      .publish({
        Subject: "Daily Sales Report",
        Message: `Your today's total sales is $ ${await fetchTotalSales()}`,
        TopicArn: process.env.TOPIC_ARN,
      })
      .promise();
    console.log("data", data);
  } catch (err) {
    console.log("err", err);
  }
  return { message: "Successfully executed" };
};

async function fetchTotalSales() {
  const fetch = await import("node-fetch");
  return fetch
    .default("https://dummyjson.com/carts")
    .then((response) => response.json())
    .then((data) => {
      let total = 0;
      total = data.carts.reduce((acc, item) => {
        return acc + item.discountedTotal;
      }, 0);
      console.log(total);
      return total.toLocaleString();
    });
}

Create Stack

Go to lib/cdk-scheduled-reporting-stack.js
Our lib/cdk-scheduled-reporting-stack.js will look like this for now.

const { Stack, Duration } = require("aws-cdk-lib");

class CdkScheduledReportingStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);
  }
}

module.exports = { CdkScheduledReportingStack };

Import modules

To create our stack, we will import several modules from aws-cdk-lib and path

const { Stack, Duration, CfnParameter } = require("aws-cdk-lib");
const lambda = require("aws-cdk-lib/aws-lambda");
const event = require("aws-cdk-lib/aws-events");
const target = require("aws-cdk-lib/aws-events-targets");
const sns = require("aws-cdk-lib/aws-sns");
const subscription = require("aws-cdk-lib/aws-sns-subscriptions");

const path = require("path");

Create Parameter

We will create an EmailAddress parameter of type string, which will be used to input an email address to which a sales report will be sent.

const emailAddress = new CfnParameter(this, "EmailAddress", {
  type: "String",
  description: "Email address to send sales report",
});

Create SNS Topic

Next, we will define Amazon SNS topic and subscribe to our EmailAddress so that when a message is published to the SNS topic, it will be sent to the email address specified in the EmailAddress parameter.

const topic = new sns.Topic(this, "SalesReportTopic", {
  displayName: "ScheduledReportingTopic",
});

topic.addSubscription(
  new subscription.EmailSubscription(emailAddress.valueAsString)
);

Create Lambda Function

Now, we will create our Lambda function and load our handler from src folder.

const salesReportFunction = new lambda.Function(this, "SalesReportFunction", {
  runtime: lambda.Runtime.NODEJS_14_X,
  code: lambda.Code.fromAsset(path.join(__dirname, "../src")),
  handler: "index.handler",
  timeout: Duration.seconds(300),
  environment: {
    TOPIC_ARN: topic.topicArn,
  },
});

Permission to publish message to SNS Topic

Next, we will give the salesReportFunction AWS Lambda function the necessary permissions to publish messages to the topic SNS topic.
This means that the Lambda function can send messages to the SNS topic, which will then distribute the messages to all of the topic's subscribers.

topic.grantPublish(salesReportFunction);

Create EventBridge Schedule Rule

Now, we will create an EventBrdige Schedule Rule that will trigger every day at 11:00 AM UTC or 06:00 PM GMT+7

const rule = new event.Rule(this, "Rule", {
  schedule: event.Schedule.expression("cron(0 11 * * ? *)"),
});

Trigger Lambda from EventBridge

Add the salesReportFunction Lambda function as a target to the rule EventBridge Schedule rule. This means that when the rule is triggered according to its schedule, it will invoke the salesReportFunction Lambda function.

rule.addTarget(new target.LambdaFunction(salesReportFunction));

Complete Stack Code

Finally, our complete stack code will look like this.

const { Stack, Duration, CfnParameter } = require("aws-cdk-lib");
const lambda = require("aws-cdk-lib/aws-lambda");
const event = require("aws-cdk-lib/aws-events");
const target = require("aws-cdk-lib/aws-events-targets");
const sns = require("aws-cdk-lib/aws-sns");
const subscription = require("aws-cdk-lib/aws-sns-subscriptions");

const path = require("path");

class CdkScheduledReportingStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    const emailAddress = new CfnParameter(this, "EmailAddress", {
      type: "String",
      description: "Email address to send sales report",
    });

    const topic = new sns.Topic(this, "SalesReportTopic", {
      displayName: "ScheduledReportingTopic",
    });

    topic.addSubscription(
      new subscription.EmailSubscription(emailAddress.valueAsString)
    );

    const salesReportFunction = new lambda.Function(
      this,
      "SalesReportFunction",
      {
        runtime: lambda.Runtime.NODEJS_14_X,
        code: lambda.Code.fromAsset(path.join(__dirname, "../src")),
        handler: "index.handler",
        timeout: Duration.seconds(300),
        environment: {
          TOPIC_ARN: topic.topicArn,
        },
      }
    );

    topic.grantPublish(salesReportFunction);

    const rule = new event.Rule(this, "Rule", {
      schedule: event.Schedule.expression("cron(0 11 * * ? *)"),
    });

    rule.addTarget(new target.LambdaFunction(salesReportFunction));
  }
}

module.exports = { CdkScheduledReportingStack };

Deploy Stack

To deploy our CDK Stack, we can run this command in our terminal.

cdk deploy --parameters EmailAddress=youremail@email.com

You can define your own email address by changing youremail@email.com value.

CDK will start synthesizing our stack like this

✨  Synthesis time: 14.44s

CdkScheduledReportingStack:  start: Building f3a91fb0ff1605e49b4b00aa223098d7a9a5307e98027f77aecc36bc05a4c3e7:current_account-current_region
CdkScheduledReportingStack:  success: Built f3a91fb0ff1605e49b4b00aa223098d7a9a5307e98027f77aecc36bc05a4c3e7:current_account-current_region
CdkScheduledReportingStack:  start: Publishing f3a91fb0ff1605e49b4b00aa223098d7a9a5307e98027f77aecc36bc05a4c3e7:current_account-current_region
CdkScheduledReportingStack:  start: Building 517f907ce2318aa1a929b43bc1a0247ed509c92576c23a0a8aadfe1677f2ebd7:current_account-current_region
CdkScheduledReportingStack:  success: Built 517f907ce2318aa1a929b43bc1a0247ed509c92576c23a0a8aadfe1677f2ebd7:current_account-current_region
CdkScheduledReportingStack:  start: Publishing 517f907ce2318aa1a929b43bc1a0247ed509c92576c23a0a8aadfe1677f2ebd7:current_account-current_region
CdkScheduledReportingStack:  success: Published 517f907ce2318aa1a929b43bc1a0247ed509c92576c23a0a8aadfe1677f2ebd7:current_account-current_region
CdkScheduledReportingStack:  success: Published f3a91fb0ff1605e49b4b00aa223098d7a9a5307e98027f77aecc36bc05a4c3e7:current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:

IAM Statement Changes
┌───┬────────────────────────────────────────┬────────┬───────────────────────┬────────────────────────────────────────┬───────────────────────────────────────────────┐
│   │ Resource                               │ Effect │ Action                │ Principal                              │ Condition                                     │
├───┼────────────────────────────────────────┼────────┼───────────────────────┼────────────────────────────────────────┼───────────────────────────────────────────────┤
│ + │ ${SalesReportFunction.Arn}             │ Allow  │ lambda:InvokeFunction │ Service:events.amazonaws.com           │ "ArnLike": {                                  │
│   │                                        │        │                       │                                        │   "AWS:SourceArn": "${Rule.Arn}"              │
│   │                                        │        │                       │                                        │ }                                             │
├───┼────────────────────────────────────────┼────────┼───────────────────────┼────────────────────────────────────────┼───────────────────────────────────────────────┤
│ + │ ${SalesReportFunction/ServiceRole.Arn} │ Allow  │ sts:AssumeRole        │ Service:lambda.amazonaws.com           │                                               │
├───┼────────────────────────────────────────┼────────┼───────────────────────┼────────────────────────────────────────┼───────────────────────────────────────────────┤
│ + │ ${SalesReportTopic}                    │ Allow  │ sns:Publish           │ AWS:${SalesReportFunction/ServiceRole} │                                               │
└───┴────────────────────────────────────────┴────────┴───────────────────────┴────────────────────────────────────────┴───────────────────────────────────────────────┘
IAM Policy Changes
┌───┬────────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│   │ Resource                           │ Managed Policy ARN                                                             │
├───┼────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${SalesReportFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

Do you wish to deploy these changes (y/n)?

After confirm the deployment, CDK will start deploying our service

CdkScheduledReportingStack: deploying... [1/1]
CdkScheduledReportingStack: creating CloudFormation changeset...
CdkScheduledReportingStack | 0/10 | 11:16:56 PM | CREATE_IN_PROGRESS   | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:1 (SalesReportTopicTokenSubscription199EB8BBD)
CdkScheduledReportingStack | 0/10 | 11:16:56 PM | CREATE_IN_PROGRESS   | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:2 (SalesReportTopicTokenSubscription246354DF1)
CdkScheduledReportingStack | 0/10 | 11:16:46 PM | REVIEW_IN_PROGRESS   | AWS::CloudFormation::Stack | CdkScheduledReportingStack User Initiated
CdkScheduledReportingStack | 0/10 | 11:16:51 PM | CREATE_IN_PROGRESS   | AWS::CloudFormation::Stack | CdkScheduledReportingStack User Initiated
CdkScheduledReportingStack | 0/10 | 11:16:55 PM | CREATE_IN_PROGRESS   | AWS::SNS::Topic         | SalesReportTopic (SalesReportTopic505419E0)
CdkScheduledReportingStack | 0/10 | 11:16:55 PM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata      | CDKMetadata/Default (CDKMetadata)
CdkScheduledReportingStack | 0/10 | 11:16:55 PM | CREATE_IN_PROGRESS   | AWS::IAM::Role          | SalesReportFunction/ServiceRole (SalesReportFunctionServiceRole3A32E4C8)
CdkScheduledReportingStack | 0/10 | 11:16:56 PM | CREATE_IN_PROGRESS   | AWS::SNS::Topic         | SalesReportTopic (SalesReportTopic505419E0) Resource creation Initiated
CdkScheduledReportingStack | 0/10 | 11:16:56 PM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata      | CDKMetadata/Default (CDKMetadata) Resource creation Initiated
CdkScheduledReportingStack | 1/10 | 11:16:56 PM | CREATE_COMPLETE      | AWS::SNS::Topic         | SalesReportTopic (SalesReportTopic505419E0)
CdkScheduledReportingStack | 2/10 | 11:16:56 PM | CREATE_COMPLETE      | AWS::CDK::Metadata      | CDKMetadata/Default (CDKMetadata)
CdkScheduledReportingStack | 2/10 | 11:16:56 PM | CREATE_IN_PROGRESS   | AWS::IAM::Role          | SalesReportFunction/ServiceRole (SalesReportFunctionServiceRole3A32E4C8) Resource creation Initiated
CdkScheduledReportingStack | 2/10 | 11:16:57 PM | CREATE_IN_PROGRESS   | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:1 (SalesReportTopicTokenSubscription199EB8BBD) Resource creation Initiated
CdkScheduledReportingStack | 3/10 | 11:16:57 PM | CREATE_COMPLETE      | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:1 (SalesReportTopicTokenSubscription199EB8BBD)
CdkScheduledReportingStack | 3/10 | 11:16:57 PM | CREATE_IN_PROGRESS   | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:2 (SalesReportTopicTokenSubscription246354DF1) Resource creation Initiated
CdkScheduledReportingStack | 4/10 | 11:16:57 PM | CREATE_COMPLETE      | AWS::SNS::Subscription  | SalesReportTopic/TokenSubscription:2 (SalesReportTopicTokenSubscription246354DF1)
CdkScheduledReportingStack | 5/10 | 11:17:12 PM | CREATE_COMPLETE      | AWS::IAM::Role          | SalesReportFunction/ServiceRole (SalesReportFunctionServiceRole3A32E4C8)
CdkScheduledReportingStack | 5/10 | 11:17:13 PM | CREATE_IN_PROGRESS   | AWS::IAM::Policy        | SalesReportFunction/ServiceRole/DefaultPolicy (SalesReportFunctionServiceRoleDefaultPolicy1B643419)
CdkScheduledReportingStack | 5/10 | 11:17:15 PM | CREATE_IN_PROGRESS   | AWS::IAM::Policy        | SalesReportFunction/ServiceRole/DefaultPolicy (SalesReportFunctionServiceRoleDefaultPolicy1B643419) Resource creation Initiated
CdkScheduledReportingStack | 6/10 | 11:17:31 PM | CREATE_COMPLETE      | AWS::IAM::Policy        | SalesReportFunction/ServiceRole/DefaultPolicy (SalesReportFunctionServiceRoleDefaultPolicy1B643419)
CdkScheduledReportingStack | 6/10 | 11:17:33 PM | CREATE_IN_PROGRESS   | AWS::Lambda::Function   | SalesReportFunction (SalesReportFunctionAFEC00DA)
CdkScheduledReportingStack | 6/10 | 11:17:35 PM | CREATE_IN_PROGRESS   | AWS::Lambda::Function   | SalesReportFunction (SalesReportFunctionAFEC00DA) Resource creation Initiated
CdkScheduledReportingStack | 7/10 | 11:17:40 PM | CREATE_COMPLETE      | AWS::Lambda::Function   | SalesReportFunction (SalesReportFunctionAFEC00DA)
CdkScheduledReportingStack | 7/10 | 11:17:41 PM | CREATE_IN_PROGRESS   | AWS::Events::Rule       | Rule (Rule4C995B7F)
CdkScheduledReportingStack | 7/10 | 11:17:42 PM | CREATE_IN_PROGRESS   | AWS::Events::Rule       | Rule (Rule4C995B7F) Resource creation Initiated
7/10 Currently in progress: CdkScheduledReportingStack, Rule4C995B7F
CdkScheduledReportingStack | 8/10 | 11:18:43 PM | CREATE_COMPLETE      | AWS::Events::Rule       | Rule (Rule4C995B7F)
CdkScheduledReportingStack | 8/10 | 11:18:44 PM | CREATE_IN_PROGRESS   | AWS::Lambda::Permission | Rule/AllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CE (RuleAllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CEB53F3E4B)
CdkScheduledReportingStack | 8/10 | 11:18:45 PM | CREATE_IN_PROGRESS   | AWS::Lambda::Permission | Rule/AllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CE (RuleAllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CEB53F3E4B) Resource creation Initiated
CdkScheduledReportingStack | 9/10 | 11:18:45 PM | CREATE_COMPLETE      | AWS::Lambda::Permission | Rule/AllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CE (RuleAllowEventRuleCdkScheduledReportingStackSalesReportFunctionA41A35CEB53F3E4B)
CdkScheduledReportingStack | 10/10 | 11:18:46 PM | CREATE_COMPLETE      | AWS::CloudFormation::Stack | CdkScheduledReportingStack

 ✅  CdkScheduledReportingStack

✨  Deployment time: 125.83s
Outputs:
CdkScheduledResportingStack.LambdaFunction = CdkScheduledResportingSta-SalesReportFunctionAFEC0-ZnCpb5NTiaaq
Stack ARN:
arn:aws:cloudformation:ap-southeast-1:00000000000:stack/CdkScheduledReportingStack/60c2ae80-7f1b-11ee-9fa0-0abc96bce958

✨  Total time: 140.27s

Pay attention to the outputs of our Lambda Function name CdkScheduledResportingSta-SalesReportFunctionAFEC0-ZnCpb5NTiaaq. We will use it later to test our Lambda function.

After the deployment is complete, you will receive a topic subscription confirmation like this that you need to confirm so that Amazon SNS can send messages to your email.

Testing

To see whether our Lambda function is working or not, we have 3 options :

Wait until the EventBridge schedule triggers our Lambda function at 11:00 AM UTC or 06:00 PM GMT+7.
Trigger it manually through AWS Management Console.
Trigger it manually through AWS CLI.

I will show you the last option, by triggering our Lambda function CdkScheduledResportingSta-SalesReportFunctionAFEC0-ZnCpb5NTiaaq manually through AWS CLI. You can do it by running the following command into your terminal.

aws lambda invoke --function-name CdkScheduledResportingSta-SalesReportFunctionAFEC0-ZnCpb5NTiaaq --invocation-type Event response.json

After running the above command, you will receive your sales notification in your email like this

By receiving the above email, that means our service is deployed and working perfectly.

Conclusion

So in this article, we successfully learn that we can deploy our serverless scheduled reporting service with AWS EventBridge, Lambda, SNS, and CDK at ease without the need to manage a server and only pay per use.

Check out my previous post

Unlocking the Power of NoSQL: Building a Todo API with Hapi.js and DynamoDB

Jimmy for AWS Community Builders ・ Oct 17 '23

#dynamodb #hapijs #serverless #node

Code Anywhere: Configure Your Personal Web-Based Code Editor with AWS CLI or AWS CDK

Jimmy — Tue, 31 Oct 2023 18:38:01 +0000

In this article, we will explore how to configure our own web-based code editor on Amazon Lightsail using either AWS CLI or AWS CDK.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

Why Choose a Web-Based Code Editor?

Web-based code editors have some cool advantages:

Easy Access: You can reach web-based code editors from any device with an internet connection, which means you can code from virtually anywhere and any device.
Teamwork: Many web-based editors support real-time collaboration, letting multiple developers work on the same code simultaneously, boosting productivity and teamwork.
No Installation Headache: You won't need to set up complex development environments on your local machine because web-based editors eliminate that requirement. This makes life easier and keeps your development team on the same page.
Platform Compatibility: Since web-based code editors run in web browsers, they work across different operating systems. Developers using various platforms can collaborate and work on the same codebase without a hitch.
Cloud Storage: Web-based code editors store your code in the cloud, reducing the risk of data loss and ensuring easy access from anywhere with an internet connection.

Installer VS Code for the Web

Installer VS Code for the Web is a nifty open-source installer script. It turns your fresh cloud Virtual Machine (VM) into a fully functional VS Code for the web with HTTPS enabled. This means you can work from any device that supports a modern web browser.

Here are some cool features of this installer:

Works on several Linux distributions.
Offers options to install ready-to-use development packages.
Automatically maps your VM's public IP address to a domain name.

Amazon Lightsail

Amazon Lightsail is like the friendly neighborhood cloud computing service provided by Amazon Web Services (AWS). It's designed to make deploying and managing cloud resources a breeze for developers, small businesses, and individuals. You won't have to deal with the complexity and learning curve associated with traditional AWS services.

We're going to transform our Amazon Lightsail instance into a fully functional web-based code editor with HTTPS capability. And we'll do it using either AWS CLI or AWS CDK.

Prerequisites

Lightsail Resource Parameters
Configure Lightsail with AWS CLI
Configure Lightsail with AWS CDK
Conclusions

Lightsail Resource Parameters

When creating Lightsail resources, there are some key parameters to keep in mind:

Availability Zone: In Amazon Lightsail, an "availability zone" is essentially a physically separate data center within an AWS region. AWS regions are divided into multiple availability zones to provide redundancy and fault tolerance. For example, in the Singapore region, you'll find availability zones like ap-southeast-1a, ap-southeast-1b, and ap-southeast-1c.
Blueprint ID: In Amazon Lightsail, a "blueprint" is a pre-made configuration template for different types of instances or applications. Blueprints make it super easy to set up instances with specific software stacks, like a LAMP (Linux, Apache, MySQL, PHP) stack or a WordPress content management system.

Name	Blueprint ID
Amazon Linux 2023	amazon_linux_2023
Amazon Linux 2	amazon_linux_2
Ubuntu	ubuntu_22_04
Ubuntu	ubuntu_20_04
Ubuntu	ubuntu_18_04
Debian	debian_11
Debian	debian_10
FreeBSD	freebsd_12
openSUSE Leap	opensuse_15
CentOS Stream 9	centos_stream_9
CentOS Linux	centos_7_2009_01
WordPress	wordpress
WordPress Multisite	wordpress_multisite
LAMP (PHP 8)	lamp_8_bitnami
Node.js	nodejs
Joomla	joomla
Magento	magento
MEAN	mean
Drupal	drupal
GitLab CE	gitlab
Redmine	redmine
Nginx	nginx
Ghost	ghost_bitnami
Django	django_bitnami
PrestaShop	prestashop_bitnami
Plesk Hosting Stack on Ubuntu	plesk_ubuntu
cPanel & WHM for AlmaLinux	cpanel_whm_almalinux

Bundle ID: A "bundle" in Amazon Lightsail refers to a set of hardware resources such as CPU, RAM, and storage allocated to a Lightsail instance. Different bundles offer varying levels of performance and capacity.

Name	Instance Type	CPU Count	RAM Size (GB)	Disk Size (GB)	Price (Monthly)	Bundle ID
Nano	nano	2	0.5	20	$3.5	nano_3_0
Micro	micro	2	1.0	40	$5.0	micro_3_0
Small	small	2	2.0	60	$10.0	small_3_0
Medium	medium	2	4.0	80	$20.0	medium_3_0
Large	large	2	8.0	160	$40.0	large_3_0
Xlarge	xlarge	4	16.0	320	$80.0	xlarge_3_0
2Xlarge	2xlarge	8	32.0	640	$160.0	2xlarge_3_0

Configure Lightsail with AWS CLI

AWS CLI (Amazon Web Services Command Line Interface) is a command-line tool from Amazon Web Services that helps you manage and interact with AWS resources and services right from your local terminal or command prompt. It's built to simplify tasks for developers, administrators, and AWS users, making it easy to automate, script, and manage your AWS infrastructure without diving into the AWS Management Console (that web-based thing).

This is step by step on how to configure our web-based code editor with AWS CLI :

Define our user data script into user-data.sh file. User data script, often referred to as a "user data" or "user script," is a script or set of commands that can be executed when launching a virtual machine (VM) or an instance in a cloud computing environment.

#!/bin/bash
export CODE_DOMAIN_NAME="\$(curl -s https://api.ipify.org).nip.io"
export CODE_PASSWORD="MyVeryLongPassword123"
curl -s -L https://raw.githubusercontent.com/rioastamal/installer-vscode-for-web/main/install.sh | bash -s -- --core

You can define your own CODE_PASSWORD value above. It is the password that you are going to use to access your web-base code editor.

Decide on the parameters that we will use to create our Lightsail instance, including availability-zone, bundle-id, and blueprint-id, using the information from the tables above.

Parameters	Value
instance-names	code-server
availability-zone	ap-southeast-1a
bundle-id	small_3_0
blueprint-id	amazon_linux_2023

Run the following command with your chosen parameters and the user-data.sh file:

aws lightsail create-instances \
    --instance-names "code-server" \
    --availability-zone "ap-southeast-1a" \
    --blueprint-id "amazon_linux_2023" \
    --bundle-id "small_3_0" \
    --user-data file://user-data.sh

To enable HTTPS for your web-based code editor, you need to open port 443 on your Lightsail instance using the following command:

aws lightsail open-instance-public-ports \
    --port-info fromPort=443,toPort=443,protocol=TCP \
    --instance-name "code-server"

Retrieve your Lightsail public IP address using the following command and store it in a variable:

public_ip=$(aws lightsail get-instance --instance-name "code-server" --query 'instance.publicIpAddress' --output text)

Display your web-based code editor URL with the https:// prefix and .nip.io suffix:

echo "Here is your Code Server URL: https://$public_ip.nip.io"

You will receive an output like this, which you can use to access your web-based code editor:

Here is your Code Server URL: https://13.212.142.172.nip.io

You can access your web-based code editor using the URL above (in several minutes) with MyVeryLongPassword123 password (if you didn't define your own CODE_PASSWORD in the user-data.sh above)

To delete your Lightsail instance you can run following command.

aws lightsail delete-instance --instance-name "code-server"

Configure Lightsail with AWS CDK

AWS CDK (Cloud Development Kit) is a nifty open-source software development framework offered by Amazon Web Services (AWS). It simplifies the process of defining, deploying, and managing AWS infrastructure and resources using familiar programming languages like TypeScript, Python, Java, C#, and others. With AWS CDK, developers can define cloud resources and infrastructure as code in their chosen programming language. It then magically turns this code into AWS CloudFormation templates for deployment.

This is step by step on how to configure our web-based code editor with AWS CDK:

Create your CDK project directory.

mkdir code-server && cd code-server

Initialized CDK project.

cdk init app --language javascript

CDK will start creating your project.

Applying project template app for javascript
# Welcome to your CDK JavaScript project

This is a blank project for CDK development with JavaScript.

The `cdk.json` file tells the CDK Toolkit how to execute your app. The build step is not required when using JavaScript.

## Useful commands

* `npm run test`         perform the jest unit tests
* `cdk deploy`           deploy this stack to your default AWS account/region
* `cdk diff`             compare deployed stack with current state
* `cdk synth`            emits the synthesized CloudFormation template

Initializing a new git repository...
warning: in the working copy of '.gitignore', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of '.npmignore', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'README.md', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'bin/code-server.js', LF will be replaced by CRLF the next time Git touches it

After your project is ready, you can go to lib/code-server-stack.js and start creating your stack.
Import aws_lightsail and CfnOutput module

const { Stack, CfnOutput } = require("aws-cdk-lib");
const aws_lightsail = require("aws-cdk-lib/aws-lightsail");

Define our user-data in a variable

const userData = `
          #!/bin/bash
          export CODE_DOMAIN_NAME="\$(curl -s https://api.ipify.org).nip.io"
          export CODE_PASSWORD="MyVeryLongPassword123"
          curl -s -L https://raw.githubusercontent.com/rioastamal/installer-vscode-for-web/main/install.sh | bash -s -- --core`;

You can define your own CODE_PASSWORD value above. It is the password that you are going to use to access your web-base code editor.

Decide on the parameters that we will use to create our Lightsail instance, including availability-zone, bundle-id, and blueprint-id, using the information from the tables above.

Parameters	Value
instanceName	code-server
availabilityZone	ap-southeast-1a
bundleId	small_3_0
blueprintId	amazon_linux_2023

Inside our constructor create Lightsail Instance using CfnInstance L1 construct.

const code_server_instance = new aws_lightsail.CfnInstance(
      this,
      "CodeServerInstance",
      {
        instanceName: "code-server",
        blueprintId: "amazon_linux_2023",
        bundleId: "small_3_0",
        userData: userData,
        availabilityZone: "ap-southeast-1a",
        networking: {
          ports: [
            {
              protocol: "tcp",
              fromPort: 80,
              toPort: 80,
            },
            {
              protocol: "tcp",
              fromPort: 443,
              toPort: 443,
            },
          ],
        },
      }
    );

Display your web-based code editor URL with the https:// prefix and .nip.io suffix:

 new CfnOutput(this, "CodeServerInstancePublicIp", {
      description: "Here is your Code Server URL:",
      value: `https://${code_server_instance.attrPublicIpAddress}.nip.io`,
    });

The complete stack code will look like this

const { Stack, CfnOutput } = require("aws-cdk-lib");
const aws_lightsail = require("aws-cdk-lib/aws-lightsail");

class CodeServerStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    const userData = `
          #!/bin/bash
          export CODE_DOMAIN_NAME="\$(curl -s https://api.ipify.org).nip.io"
          export CODE_PASSWORD="MyVeryLongPassword123"
          curl -s -L https://raw.githubusercontent.com/rioastamal/installer-vscode-for-web/main/install.sh | bash -s -- --core`;

    const code_server_instance = new aws_lightsail.CfnInstance(
      this,
      "CodeServerInstance",
      {
        instanceName: "code-server",
        blueprintId: "amazon_linux_2023",
        bundleId: "small_3_0",
        userData: userData,
        availabilityZone: "ap-southeast-1a",
        networking: {
          ports: [
            {
              protocol: "tcp",
              fromPort: 80,
              toPort: 80,
            },
            {
              protocol: "tcp",
              fromPort: 443,
              toPort: 443,
            },
          ],
        },
      }
    );

    new CfnOutput(this, "CodeServerInstancePublicIp", {
      description: "Here is your Code Server URL:",
      value: `https://${code_server_instance.attrPublicIpAddress}.nip.io`,
    });
  }
}

module.exports = { CodeServerStack };

Deploy your CDK stack using this command in your terminal.

cdk deploy

CDK will start synth and create changeset.

  Synthesis time: 0.51s

CodeServerStack:  start: Building 3d55542ca41bb6bafa251e4852dc0edd7b9609b642fc773fc3115d91600140f1:current_account-current_region
CodeServerStack:  success: Built 3d55542ca41bb6bafa251e4852dc0edd7b9609b642fc773fc3115d91600140f1:current_account-current_region
CodeServerStack:  start: Publishing 3d55542ca41bb6bafa251e4852dc0edd7b9609b642fc773fc3115d91600140f1:current_account-current_region
CodeServerStack:  success: Published 3d55542ca41bb6bafa251e4852dc0edd7b9609b642fc773fc3115d91600140f1:current_account-current_region
CodeServerStack: deploying... [1/1]
CodeServerStack: creating CloudFormation changeset...
CodeServerStack | 0/3 | 1:14:59 AM | REVIEW_IN_PROGRESS   | AWS::CloudFormation::Stack | CodeServerStack User Initiated
CodeServerStack | 0/3 | 1:15:05 AM | CREATE_IN_PROGRESS   | AWS::CloudFormation::Stack | CodeServerStack User Initiated
CodeServerStack | 0/3 | 1:15:08 AM | CREATE_IN_PROGRESS   | AWS::Lightsail::Instance | CodeServerInstance 
CodeServerStack | 0/3 | 1:15:08 AM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata       | CDKMetadata/Default (CDKMetadata) 
CodeServerStack | 0/3 | 1:15:09 AM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata       | CDKMetadata/Default (CDKMetadata) Resource creation Initiated
CodeServerStack | 1/3 | 1:15:09 AM | CREATE_COMPLETE      | AWS::CDK::Metadata       | CDKMetadata/Default (CDKMetadata) 
CodeServerStack | 1/3 | 1:15:12 AM | CREATE_IN_PROGRESS   | AWS::Lightsail::Instance | CodeServerInstance Resource creation Initiated
CodeServerStack | 2/3 | 1:15:29 AM | CREATE_COMPLETE      | AWS::Lightsail::Instance | CodeServerInstance
CodeServerStack | 3/3 | 1:15:31 AM | CREATE_COMPLETE      | AWS::CloudFormation::Stack | CodeServerStack

 ✅  CodeServerStack

✨  Deployment time: 37.54s

You will receive an output like this, which you can use to access your web-based code editor:

Outputs:
CodeServerStack.CodeServerInstancePublicIp = https://13.229.52.187.nip.io
Stack ARN:
arn:aws:cloudformation:ap-southeast-1:319450934564:stack/CodeServerStack/122214b0-7687-11ee-94cb-0a2ad276ae8c

✨  Total time: 38.04s

You can access your web-based code editor using the URL above (in several minutes) with MyVeryLongPassword123 password (if you didn't define your own CODE_PASSWORD in the user-data.sh above)

To delete your Lightsail instance you can run following command.

cdk destroy

Conclusions

In conclusion, we've explored just how straightforward it is to accomplish our goal of creating a web-based code editor on our Amazon Lightsail instance. Either with AWS CLI or AWS CDK. With the power of AWS dev tools at our fingertips, developers can streamline their workflows and boost productivity, all while enjoying the flexibility of choice in their development tools.

Check out my previous post

Unlocking the Power of NoSQL: Building a Todo API with Hapi.js and DynamoDB

Jimmy for AWS Community Builders ・ Oct 17 '23

#dynamodb #hapijs #serverless #node

Deploy & Run your Node.js Framework App on AWS Lambda with AWS Lambda Web Adapter

Jimmy — Tue, 24 Oct 2023 09:54:49 +0000

In this article, we'll explore the process of deploying and running a serverless application on AWS Lambda built with Node.js framework such as Hapi.js and NoSQL database like Dynamodb.

In this article, we will use the application that we previously built from this article.

We will use AWS Lambda Web Adapter to run our Node.js Application on AWS Lambda.

AWS Lambda Web Adapter allows developers to build web apps (http api) with familiar frameworks (e.g. Express.js, Next.js, Flask, SpringBoot, ASP.NET and Laravel, anything speaks HTTP 1.1/1.0) and run it on AWS Lambda.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

AWS Lambda

AWS Lambda is a serverless computing service provided by Amazon Web Services (AWS). It allows you to run code without having to provision or manage servers. With Lambda, you can focus on writing your application code and let AWS handle the infrastructure management, scaling, and server maintenance.

Amazon DynamoDB

Amazon DynamoDB is a fully managed NoSQL database service provided by Amazon Web Services (AWS). It is designed to provide fast and scalable performance for applications that require flexible and reliable data storage. DynamoDB is particularly well-suited for web and mobile applications, gaming backends, content management systems, and other use cases that need low-latency, highly available, and scalable databases.

AWS Serverless Application Model

AWS SAM (Serverless Application Model) is an open-source framework provided by Amazon Web Services (AWS) for building serverless applications. It extends AWS CloudFormation, which is AWS's infrastructure as code service, to provide a simplified way of defining the resources and configurations needed to deploy serverless applications on AWS.

Node.js

Node.js is an open-source, server-side runtime environment that allows developers to build and run server-side applications using JavaScript. It is built on the V8 JavaScript engine, which is the same engine used in Google Chrome, and it enables the execution of JavaScript code on the server, rather than just in web browsers.

Node.js Framework

Node.js has a rich ecosystem of frameworks and libraries to simplify web application development. Some popular Node.js frameworks and libraries include:

Express.js
Koa.js
Sails.js
Hapi.js
Nest.js

In this article, we will deploy and run our application built with Hapi.js and Amazon DynamoDB.

Prerequisites Tools

Project Folder Structure
Dockerfile
AWS SAM Template.yaml
AWS SAM Deploy
Test
Cleanup
Conclusions

Project Folder Structure

Our project folder structure will looks like this

.
|-- app
|   |-- src
|   `-- Dockerfile
`-- template.yaml

src is a folder that will houses our Node.js application.
Dockerfile is a text file used to define a set of instructions for building our Docker container image.
template.yaml is an AWS SAM template, providing a streamlined layer on top of CloudFormation, simplifying the definition and deployment of our serverless applications.

Dockerfile

This is how our Dockerfile looks like

FROM public.ecr.aws/docker/library/node:16.13.2-stretch-slim
COPY --from=public.ecr.aws/awsguru/aws-lambda-adapter:0.7.1 /lambda-adapter /opt/extensions/lambda-adapter
EXPOSE 8080
WORKDIR "/var/task"
ADD src/package.json /var/task/package.json
ADD src/package-lock.json /var/task/package-lock.json
RUN npm install --omit=dev
ADD src/ /var/task
CMD ["node", "index.js"]

This is a Dockerfile that defines the build instructions for a Docker image. The image is based on the node:16.13.2-stretch-slim image from Docker Hub, which is a lightweight version of the Node.js runtime environment.

To use Lambda Web Adapter with docker images, add one line to copy Lambda Web Adapter binary to /opt/extensions inside your container.

The Dockerfile starts by copying the lambda-adapter binary from another Docker image (public.ecr.aws/awsguru/aws-lambda-adapter:0.7.1) to the /opt/extensions/lambda-adapter directory in the new image.

The EXPOSE instruction is used to indicate that the container will listen on port 8080. This does not actually publish the port, but it is a useful hint for anyone who wants to run the container.

The WORKDIR instruction sets the working directory for subsequent instructions to /var/task. This is the directory where the Lambda function code will be located.

The ADD instructions copy the package.json, package-lock.json, and source code files from the src directory to the /var/task directory in the image. The npm install command is then run to install the dependencies specified in package.json. The --omit=dev flag is used to exclude development dependencies from the installation, which can help reduce the size of the final image.

Finally, the CMD instruction specifies the command that should be run when a container is started from the image. In this case, it runs the node command with index.js as the argument, which is the entry point for the Lambda function.

SAM Template

AWS SAM (Serverless Application Model) template is a JSON or YAML configuration file used to define the AWS resources and configurations required to deploy a serverless application on Amazon Web Services (AWS).

This is how our complete AWS SAM template will look like.

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Todo Application

Resources:
  TodoFunction:
    Type: AWS::Serverless::Function
    Properties:
      PackageType: Image
      MemorySize: 1024
      Timeout: 30
      Environment:
        Variables:
          RUST_LOG: info
          TABLE_NAME: !Ref TodoTable
      Events:
        Root:
          Type: HttpApi
          Properties:
            Path: /
            Method: ANY
        Petstore:
          Type: HttpApi
          Properties:
            Path: /{proxy+}
            Method: ANY
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref TodoTable
    Metadata:
      DockerTag: v1
      DockerContext: ./app
      Dockerfile: Dockerfile

  TodoTable:
    Type: AWS::Serverless::SimpleTable
    Properties:
      PrimaryKey:
        Name: id
        Type: String

Outputs:
  TodoApi:
    Description: "API Gateway endpoint URL for Prod stage for Todo function"
    Value: !Sub "https://${ServerlessHttpApi}.execute-api.${AWS::Region}.${AWS::URLSuffix}/"

First, we defined our Lambda Function resource like this in our template.

TodoFunction:
  Type: AWS::Serverless::Function
  Properties:
    PackageType: Image
    MemorySize: 1024
    Timeout: 30
    Environment:
      Variables:
        RUST_LOG: info
        TABLE_NAME: !Ref TodoTable
    Events:
      Root:
        Type: HttpApi
        Properties:
          Path: /
          Method: ANY
      Petstore:
        Type: HttpApi
        Properties:
          Path: /{proxy+}
          Method: ANY
    Policies:
      - DynamoDBCrudPolicy:
          TableName: !Ref TodoTable
  Metadata:
    DockerTag: v1
    DockerContext: ./app
    Dockerfile: Dockerfile

The above template part defines an AWS Lambda function named TodoFunction that is used to handle HTTP requests for a RESTful API.

The Type property specifies that this resource is an AWS::Serverless::Function, which is a type of AWS Lambda function that can be defined using the SAM template format.

The Properties section contains various configuration options for the function. The PackageType property is set to Image, which means that the function will be packaged as a Docker image. The MemorySize property is set to 1024 MB, which is the amount of memory that will be allocated to the function when it runs. The Timeout property is set to 30 seconds, which is the maximum amount of time that the function can run before it is terminated.

The Environment section contains environment variables that will be available to the function at runtime. In this case, there are two variables defined: RUST_LOG and TABLE_NAME. The RUST_LOG variable is set to info, which is a logging level for the Rust programming language. The TABLE_NAME variable is set to the name of a DynamoDB table that the function will interact with. The !Ref function is used to reference the TodoTable resource defined elsewhere in the template.

The Events section defines the events that will trigger the function. In this case, there are two events defined: Root and Petstore. Both events are of type HttpApi, which means that they will be triggered by HTTP requests. The Path property specifies the URL path that will trigger the event, and the Method property specifies the HTTP method that will trigger the event.

The Policies section defines the IAM policies that are attached to the function. In this case, there is one policy defined: DynamoDBCrudPolicy. This policy grants the function permissions to perform CRUD (Create, Read, Update, Delete) operations on the DynamoDB table specified in the TableName property. The !Ref function is used to reference the TodoTable resource defined elsewhere in the template.

The Metadata section contains metadata about the function. In this case, it specifies the Docker tag, Docker context, and Dockerfile that will be used to build the Docker image for the function.

Then we create our Amazon DynamoDB table

TodoTable:
  Type: AWS::Serverless::SimpleTable
  Properties:
    PrimaryKey:
      Name: id
      Type: String

The above template part defines an AWS DynamoDB table named TodoTable that will be used to store data for a RESTful API.

The Type property specifies that this resource is an AWS::Serverless::SimpleTable, which is a type of DynamoDB table that can be defined using the SAM template format.

The Properties section contains various configuration options for the table. The PrimaryKey property specifies the primary key for the table, which consists of a single attribute named id of type String. This means that the id attribute will be used as the partition key for the table.

Last, we defined our function's API Gateway endpoint URL output

Outputs:
  NodejsApi:
    Description: "API Gateway endpoint URL for Prod stage for Todo function"
    Value: !Sub "https://${ServerlessHttpApi}.execute-api.${AWS::Region}.${AWS::URLSuffix}/"

It defines an output named TodoApi that provides the URL for the API Gateway endpoint for the TodoFunction resource.

The Outputs section of the template is used to define values that can be exported from the stack. These values can be used by other stacks or by external applications to interact with the resources in the stack.

The TodoApi output has a Description property that provides a brief description of the output. In this case, it describes the output as the API Gateway endpoint URL for the Prod stage of the TodoFunction resource.

The Value property is a !Sub function that substitutes variables in a string with their corresponding values. In this case, it substitutes the ${ServerlessHttpApi} variable with the name of the HTTP API that is created for the TodoFunction resource, and the ${AWS::Region} and ${AWS::URLSuffix} variables with the AWS region and URL suffix, respectively.

AWS SAM Deploy

To start deploying our serverless application we can run this command in our terminal

sam build
sam deploy --guided

sam deploy --guided is a command provided by the AWS SAM (Serverless Application Model) CLI (Command Line Interface) that launches an interactive, guided deployment process for your serverless application. This command helps you deploy your application with AWS SAM in an easy and user-friendly manner.

When you run sam deploy --guided, you will be asked for some configurations input, which you can fill in like this.

Configuring SAM deploy
======================

        Looking for config file [samconfig.toml] :  Found
        Reading default arguments  :  Success

        Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [sam-app]: hapijs-todoapp
        AWS Region [ap-southeast-1]: ap-southeast-1
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [y/N]: y
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]: Y
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]: N
        ExpressFunction has no authentication. Is this okay? [y/N]: y
        ExpressFunction has no authentication. Is this okay? [y/N]: y
        Save arguments to configuration file [Y/n]: Y
        SAM configuration file [samconfig.toml]: samconfig.toml
        SAM configuration environment [default]: default

AWS SAM will start looking for resources needed for deployment we defined in our template.

Looking for resources needed for deployment:

        Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-1aa02zp34lw9q
        A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
         Image repositories: Not found.
         #Managed repositories will be deleted when their functions are removed from the template and deployed
         Create managed ECR repositories for all functions? [Y/n]:

        Saved arguments to config file
        Running 'sam deploy' for future deployments will use the parameters saved above.
        The above parameters can be changed by modifying samconfig.toml
        Learn more about samconfig.toml syntax at
        https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html

eb03fb97f024: Pushed
421b36cec0ce: Pushed
85de5da90a78: Pushed
29f371b320ea: Pushed
f2ca56bec846: Pushed
7c5fbd8aa99c: Pushed
1b4d47b7a3e7: Pushed
a3a67812fd2d: Pushed
cb6798486542: Pushed
cb0076c98b2c: Pushed
8f0b8fdd795f: Pushed
todofunction-4014533baa38-v1: digest: sha256:105bc7c6ce5aadd80e2c6e2fb96a64f2dde41a24600499fc442ac64f7f7f52f0 size: 2623

Then SAM will start initiating deployment

Initiating deployment
=====================

TodoFunction has no authentication.
TodoFunction has no authentication.
        Uploading to hapijs-todoapp/1599f63c1d296a53c88fc482c7d09a71.template  1413 / 1413  (100.00%)


Waiting for changeset to be created..

CloudFormation stack changeset
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Operation                                     LogicalResourceId                             ResourceType                                  Replacement
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Add                                         ServerlessHttpApiApiGatewayDefaultStage       AWS::ApiGatewayV2::Stage                      N/A
+ Add                                         ServerlessHttpApi                             AWS::ApiGatewayV2::Api                        N/A
+ Add                                         TodoFunctionPetstorePermission                AWS::Lambda::Permission                       N/A
+ Add                                         TodoFunctionRole                              AWS::IAM::Role                                N/A
+ Add                                         TodoFunctionRootPermission                    AWS::Lambda::Permission                       N/A
+ Add                                         TodoFunction                                  AWS::Lambda::Function                         N/A
+ Add                                         TodoTable                                     AWS::DynamoDB::Table                          N/A
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Then after completing the deployment, AWS SAM will return an output of the endpoint URL like this.

Outputs
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Key                 TodoApi
Description         API Gateway endpoint URL for Prod stage for Todo function
Value               https://fr9mddpdg7.execute-api.ap-southeast-1.amazonaws.com/

We'll initiate testing our application using the output endpoint URL https://fr9mddpdg7.execute-api.ap-southeast-1.amazonaws.com/.

For the next subsequent deployment or after modifying AWS SAM template, you can just run this command.

sam build
sam deploy

Test

To verify the functionality of our Endpoint URL, we can execute the following commands to both send new data and retrieve the corresponding response:

$ curl -k -X POST \
> -H "Content-Type: application/json" \
> -d '{"title":"Deploy and Run Node.js Application on AWS Lambda"}' \
> https://fr9mddpdg7.execute-api.ap-southeast-1.amazonaws.com/todos

{"$metadata":{"httpStatusCode":200,"requestId":"KDTCSC5G29C07JE6TM0V4QH0VRVV4KQNSO5AEMVJF66Q9ASUAAJG","attempts":1,"totalRetryDelay":0}}

Subsequently, we can retrieve the data we previously posted by executing this command and inspecting the response:

$ curl -k  https://fr9mddpdg7.execute-api.ap-southeast-1.amazonaws.com/todos

{"response":[{"id":"1698140034538","iscompleted":false,"title":"Deploy and Run Node.js Application on AWS Lambda"}]}

The above commands demonstrate the successful deployment and execution of our Node.js application on AWS Lambda, connected to an Amazon DynamoDB database.

Cleanup

To remove our serverless application deployed using AWS SAM, execute the following command:

sam delete

sam delete will delete an AWS SAM application by deleting the AWS CloudFormation stack, the artifacts that were packaged and deployed to Amazon S3 and Amazon ECR, and the AWS SAM template file.

Conclusions

In this article, we discover that we can deploy and execute our Node.js application on AWS Lambda, leveraging the capabilities of the AWS Lambda Web Adapter.

Check out my previous post

Serverless Scheduled Reporting Service with AWS EventBridge, Lambda, SNS, and CDK

Jimmy for AWS Community Builders ・ Nov 9 '23

#aws #serverless #lambda #cdk

Local Serverless Application Development with AWS SAM and Localstack

Jimmy — Wed, 18 Oct 2023 08:32:31 +0000

Are you looking for cost-efficient and streamlined local development and testing of serverless applications built with AWS services like Amazon API Gateway, AWS Lambda, and Amazon DynamoDB?

With AWS SAM and Localstack, you can emulate AWS services on a local machine and allow developers to work offline, saving costs and enabling rapid iteration.

In this article, we will explore on how to build a serverless API service and test it locally with AWS SAM and Localstack.

Follow me for more

FullStack Saiyan | Twitter, Instagram, Facebook | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

AWS Serverless Application Model (SAM)

AWS SAM (Serverless Application Model) is an open-source framework for building serverless applications. It extends AWS CloudFormation to provide a simplified way of defining the Amazon API Gateway APIs, AWS Lambda functions, and Amazon DynamoDB tables needed by your serverless application.

To install AWS SAM you can refer to this AWS documentation page for detailed installation. Install AWS SAM

We will also need to install AWS CLI. You can refer to this documentation Install AWS CLI.

Localstack

Localstack is an open-source project that provides a fully functional local AWS cloud stack for development and testing purposes. It allows developers to emulate several AWS services on their local machines, enabling them to develop and test their applications without accessing the actual AWS cloud.

LocalStack aims to replicate the behavior of various AWS services, such as Amazon S3, Amazon DynamoDB, AWS Lambda, Amazon SQS, and many others. Developers can interact with these emulated services through the AWS SDKs or command-line tools, just as they would with the real AWS services.

To install Localstack you can refer to this AWS documentation page for detailed installation. Install Localstack

Docker

Both AWS SAM and Localstack utilize Docker to run simulate AWS Service locally, so we will be using Docker also.

Docker is a platform and a set of tools designed to simplify the creation, deployment, and running of applications using containers. Containers are lightweight, portable, and consistent environments that encapsulate an application and its dependencies. Docker allows developers to package an application and its dependencies into a container image, which can then be easily distributed and run consistently across different environments.

To install Docker, you can also check Docker documentation page for detailed installation. Install Docker Engine

Create project with AWS SAM.

We can start creating and initializing our AWS SAM project using this command.

sam init

Then we can follow this configuration wizard to start creating our Todo API service. --- For the template source we can choose 1- AWS Quick Start Templates

You can preselect a particular runtime or package type when using the `sam init` experience.
Call `sam init --help` to learn more.

Which template source would you like to use?
        1 - AWS Quick Start Templates
        2 - Custom Template Location
Choice: 1

For the AWS Quick Start application template, we can choose 7 - Serverless API

Choose an AWS Quick Start application template
        1 - Hello World Example
        2 - Data processing
        3 - Hello World Example with Powertools for AWS Lambda
        4 - Multi-step workflow
        5 - Scheduled task
        6 - Standalone function
        7 - Serverless API
        8 - Infrastructure event management
        9 - Lambda Response Streaming
        10 - Serverless Connector Hello World Example
        11 - Multi-step workflow with Connectors
        12 - GraphQLApi Hello World Example
        13 - Full Stack
        14 - Lambda EFS example
        15 - Hello World Example With Powertools for AWS Lambda
        16 - DynamoDB Example
        17 - Machine Learning
Template: 7

For runtime we can choose 2 - nodejs18.x

Which runtime would you like to use?
        1 - dotnet6
        2 - nodejs18.x
        3 - nodejs16.x
        4 - nodejs14.x
Runtime: 2

For enable X-Ray tracing, choose N

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: N

Choose N for enable monitoring using CloudWatch Application Insights

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: N

Project name, type serverless-api

Project name [sam-app]: serverless-api

The complete SAM CLI configuration will look like this.

You can preselect a particular runtime or package type when using the `sam init` experience.
Call `sam init --help` to learn more.

Which template source would you like to use?
        1 - AWS Quick Start Templates
        2 - Custom Template Location
Choice: 1

Choose an AWS Quick Start application template
        1 - Hello World Example
        2 - Data processing
        3 - Hello World Example with Powertools for AWS Lambda
        4 - Multi-step workflow
        5 - Scheduled task
        6 - Standalone function
        7 - Serverless API
        8 - Infrastructure event management
        9 - Lambda Response Streaming
        10 - Serverless Connector Hello World Example
        11 - Multi-step workflow with Connectors
        12 - GraphQLApi Hello World Example
        13 - Full Stack
        14 - Lambda EFS example
        15 - Hello World Example With Powertools for AWS Lambda
        16 - DynamoDB Example
        17 - Machine Learning
Template: 7

Which runtime would you like to use?
        1 - dotnet6
        2 - nodejs18.x
        3 - nodejs16.x
        4 - nodejs14.x
Runtime: 2

Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.

Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.

Would you like to enable X-Ray tracing on the function(s) in your application?  [y/N]: N

Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: N

Project name [sam-app]: serverless-api

    -----------------------
    Generating application:
    -----------------------
    Name: serverless-api
    Runtime: nodejs18.x
    Architectures: x86_64
    Dependency Manager: npm
    Application Template: quick-start-web
    Output Directory: .
    Configuration file: serverless-api\samconfig.toml

    Next steps can be found in the README file at serverless-api\README.md


Commands you can use next
=========================
[*] Create pipeline: cd serverless-api && sam pipeline init --bootstrap
[*] Validate SAM template: cd serverless-api && sam validate
[*] Test Function in the Cloud: cd serverless-api && sam sync --stack-name {stack-name} --watch

AWS SAM will then generate our serverless-api project according to the configuration we chose above like this.

.
|-- README.md
|-- __tests__
|   `-- unit
|       `-- handlers
|-- buildspec.yml
|-- env.json
|-- events
|   |-- event-get-all-items.json
|   |-- event-get-by-id.json
|   `-- event-post-item.json
|-- package.json
|-- samconfig.toml
|-- src
|   `-- handlers
|       |-- get-all-items.mjs
|       |-- get-by-id.mjs
|       `-- put-item.mjs
`-- template.yaml

src/handlers is where our Lambda function will be, and template.yaml is our AWS SAM template.

Our project architecture above will look like this

In this project, we are using several AWS Services like

API Gateway
Lambda
DynamoDB

So we need a way to emulate these services locally.

Next, we will explore how to run our project and emulate AWS services locally using AWS SAM.

Run and Test Locally with AWS SAM

Run DynamoDB locally

AWS SAM doesn't emulate DynamoDB service that we are going to use in our project. So we need to run DynamoDB locally.

Amazon DynamoDB provides a way to run DynamoDB locally on our computer. Deploying DynamoDB locally on your computer

So we will run our DynamoDB locally using Docker.

Create docker-compose.yml
Type the following code

version: '3.8'
services:
 dynamodb-local:
   command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
   image: "amazon/dynamodb-local:latest"
   container_name: dynamodb-local
   ports:
     - "8000:8000"
   volumes:
     - "./docker/dynamodb:/home/dynamodblocal/data"
   working_dir: /home/dynamodblocal

Run the following command in your terminal

docker-compose up

Check whether our Dynamodb container is successfully running

$ docker ps
CONTAINER ID   IMAGE                                          COMMAND                  CREATED          STATUS          PORTS                      NAMES
e7d0b58896e5   amazon/dynamodb-local:latest                   "java -jar DynamoDBL…"   2 months ago     Up 2 hours      0.0.0.0:8000->8000/tcp     dynamodb-local

Take note on our dynamodb container name which is dynamodb-local and the dynamodb network named dynamodb_default. We will be using this information to configure our application to run locally depending on the ENVIRONMENT variable.

Create our DynamoDB table inside our local DynamoDB

To create our DynamoDB table inside our local DynamoDB, we can run this command

aws dynamodb create-table \
    --table-name SampleTable \
    --attribute-definitions \
        AttributeName=id,AttributeType=S \
    --key-schema \
        AttributeName=id,KeyType=HASH \
    --provisioned-throughput \
        ReadCapacityUnits=2,WriteCapacityUnits=2 \
    --table-class STANDARD \
    --endpoint-url http://localhost:8000

As you notice, we will run above command into our local DynamoDB endpoint using this flag --endpoint-url HTTP://localhost:8000

Modify our `template.yaml` and function handlers

First we will modify our template.yaml by adding this configuration

Globals:
  Function:
    Environment:
      Variables:
        ENVIRONMENT: "local"

So that our complete template.yaml configuration will looks like this.

AWSTemplateFormatVersion: 2010-09-09
Description: >-
  serverless-api

Transform:
  - AWS::Serverless-2016-10-31

Globals:
  Function:
    Environment:
      Variables:
        ENVIRONMENT: "local"

Resources:
  getAllItemsFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/get-all-items.getAllItemsHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
      MemorySize: 128
      Timeout: 100
      Description: A simple example includes a HTTP get method to get all items from a DynamoDB table.
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref SampleTable
      Environment:
        Variables:
          SAMPLE_TABLE: !Ref SampleTable
      Events:
        Api:
          Type: Api
          Properties:
            Path: /
            Method: GET

  getByIdFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/get-by-id.getByIdHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
      MemorySize: 128
      Timeout: 100
      Description: A simple example includes a HTTP get method to get one item by id from a DynamoDB table.
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref SampleTable
      Environment:
        Variables:
          SAMPLE_TABLE: !Ref SampleTable
      Events:
        Api:
          Type: Api
          Properties:
            Path: /{id}
            Method: GET

  putItemFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/put-item.putItemHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
      MemorySize: 128
      Timeout: 100
      Description: A simple example includes a HTTP post method to add one item to a DynamoDB table.
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref SampleTable
      Environment:
        Variables:
          SAMPLE_TABLE: !Ref SampleTable
      Events:
        Api:
          Type: Api
          Properties:
            Path: /
            Method: POST

  SampleTable:
    Type: AWS::Serverless::SimpleTable
    Properties:
      PrimaryKey:
        Name: id
        Type: String
      ProvisionedThroughput:
        ReadCapacityUnits: 2
        WriteCapacityUnits: 2

Outputs:
  WebEndpoint:
    Description: "API Gateway endpoint URL for Prod stage"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"

Next, we will modify all our function handler get-all-items.mjs, get-by-id.mjs and put-item-mjs. We will modify this part of the code.

const client = new DynamoDBClient();

into

const client = new DynamoDBClient(
  process.env.ENVIRONMENT === "local"
    ? {
        endpoint: "http://dynamodb-local:8000",
      }
    : {}
);

Run and Test Locally

Finally, we can start running and testing our project locally using AWS SAM.

AWS SAM provides several commands for us to run our function locally like:

sam local invoke

This command is used to initiate a one-time invocation of an AWS Lambda function locally.

$ sam local invoke
Invoking app.lambda_handler (python3.9)
Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image
Building image....................................................................................................................
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST
END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df
REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df  Init Duration: 1.09 ms  Duration: 608.42 ms       Billed Duration: 609 ms Memory Size: 128 MB     Max Memory Used: 128 MB
{"statusCode": 200, "body": "{\"message\": \"hello world\"}"}%

sam local start-api

This command is used to run your AWS Lambda functions locally and test through a local HTTP server host. This type of test is helpful for Lambda functions that are invoked by an Amazon API Gateway endpoint.

$ sam local start-api

Initializing the lambda functions containers.
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

 * Running on http://127.0.0.1:3000

sam local start-lambda

This command is used to invoke your AWS Lambda function through the AWS Command Line Interface (AWS CLI) or SDKs. This command starts a local endpoint that emulates AWS Lambda.

$ sam local start-lambda
Initializing the lambda functions containers.
Local image is up-to-date
Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64.

 * Running on http://127.0.0.1:3001
2023-04-13 07:25:43 Press CTRL+C to quit

Because we want to emulate Amazon API Gateway and AWS Lambda services, we will use sam local start-api and using our dynamodb container network dynamodb_default

sam local start-api --docker-network dynamodb_default

Initializing the lambda functions containers.
Local image is up-to-date
Local image is up-to-date
Local image is up-to-date
Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64.

Containers Initialization is done.
Mounting getAllItemsFunction at http://127.0.0.1:3000/ [GET]
Mounting putItemFunction at http://127.0.0.1:3000/ [POST]
Mounting getByIdFunction at http://127.0.0.1:3000/{id} [GET]
You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected   
instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart  
SAM CLI if you update your AWS SAM template
2023-11-17 00:32:55 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:3000
2023-11-17 00:32:55 Press CTRL+C to quit

sam local start-api will emulate our function through this endpoint

Mounting getAllItemsFunction at http://127.0.0.1:3000/ [GET]
Mounting putItemFunction at http://127.0.0.1:3000/ [POST]
Mounting getByIdFunction at http://127.0.0.1:3000/{id} [GET]

So we can test POST item by running this command in new terminal.

$ curl -X POST -H "Content-Type: application/json" -d '{"id":"3","name":"test"}' http://localhost:3000
{"id":"3","name":"test"}

And, test GET all items using this command

$ curl http://localhost:3000
[{"name":"test","id":"1"},{"name":"test","id":"2"}]

Run and Test Locally with Localstack

With Localstack the step to run and test locally will be more easier.

But first we need to configure our template.yaml again.

Globals:
  Function:
    Environment:
      Variables:
        ENVIRONMENT: "localstack"

we are changing our ENVIRONMENT variable into localstack so that our DynamoDBCLient will connect directly inside Localstack DynamoDB.

Then we will modify the output of our endpoint into this so that it will output Localstack endpoint that we can use to test our application.

Outputs:
  WebEndpoint:
    Description: "API Gateway endpoint URL for Prod stage"  
    Value: !Sub "http://${ServerlessRestApi}.execute-api.localhost.localstack.cloud:4566/Prod/"

Install `samlocal`

To emulate AWS services locally with Localstack, we can install and use samlocal, a wrapper for the AWS SAM CLI, so that every aws sam commands will be executed against the Localstack endpoints (http://localhost:4566 by default) instead of real AWS endpoints.

You can install it using these commands.

pip install aws-sam-cli-local

Deploy project to Localstack

To deploy our project to Localstack, we can run this command

samlocal deploy

samlocal will deploy your project but not into AWS but into Localstack.

                Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-b1dc8c32
                A different default S3 bucket can be set in samconfig.toml
                Or by specifying --s3-bucket explicitly.
        Uploading to 9a5628197c0aebb840bb53c26bf4e03c  11801 / 11801  (100.00%)
File with same data already exists at 9a5628197c0aebb840bb53c26bf4e03c, skipping upload
File with same data already exists at 9a5628197c0aebb840bb53c26bf4e03c, skipping upload

        Deploying with following values
        ===============================
        Stack name                   : serverless-api
        Region                       : ap-southeast-1
        Confirm changeset            : True
        Disable rollback             : False
        Deployment s3 bucket         : aws-sam-cli-managed-default-samclisourcebucket-b1dc8c32
        Capabilities                 : ["CAPABILITY_IAM"]
        Parameter overrides          : {}
        Signing Profiles             : {}

Initiating deployment
=====================

        Uploading to 1245f569e29a8187dfbd04b64f50e277.template  3166 / 3166  (100.00%)


Waiting for changeset to be created..

CloudFormation stack changeset
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------     
Operation                                         LogicalResourceId                                 ResourceType                                      Replacement
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------     
* Modify                                          putItemFunctionApiPermissionProd                  AWS::Lambda::Permission                           False
* Modify                                          putItemFunction                                   AWS::Lambda::Function                             False
* Modify                                          getAllItemsFunction                               AWS::Lambda::Function                             False
* Modify                                          getByIdFunctionRole                               AWS::IAM::Role                                    False
* Modify                                          getAllItemsFunctionApiPermissionProd              AWS::Lambda::Permission                           False
* Modify                                          getAllItemsFunctionRole                           AWS::IAM::Role                                    False
* Modify                                          putItemFunctionRole                               AWS::IAM::Role                                    False
* Modify                                          getByIdFunction                                   AWS::Lambda::Function                             False
* Modify                                          ServerlessRestApiProdStage                        AWS::ApiGateway::Stage                            False
* Modify                                          ServerlessRestApiDeploymenta4d359a69a             AWS::ApiGateway::Deployment                       False
* Modify                                          ServerlessRestApi                                 AWS::ApiGateway::RestApi                          False
* Modify                                          getByIdFunctionApiPermissionProd                  AWS::Lambda::Permission                           False
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------     


Changeset created successfully. arn:aws:cloudformation:ap-southeast-1:000000000000:changeSet/samcli-deploy1700159060/1d7348f1

Once your project is deployed into Localstack locally, samlocal will return this output

CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
Outputs
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
Key                 WebEndpoint
Description         API Gateway endpoint URL for Prod stage
Value               http://a4uowlkucn.execute-api.localhost.localstack.cloud:4566/Prod/

Finally, we can test our service through Localstack endpoint http://a4uowlkucn.execute-api.localhost.localstack.cloud:4566/Prod/ by running this command
So we can test POST item by running this command in new terminal.

$ curl -X POST -H "Content-Type: application/json" -d '{"id":"3","name":"test"}' http://a4uowlkucn.execute-api.localhost.localstack.cloud:4566/Prod/
{"id":"3","name":"test"}

And, test GET all items using this command

$ curl http://a4uowlkucn.execute-api.localhost.localstack.cloud:4566/Prod/
[{"name":"test","id":"1"},{"name":"test","id":"2"}]

Conclusions

While AWS SAM provides a means to run and test serverless services locally, the process is significantly streamlined with Localstack. Localstack not only facilitates the local execution and testing of serverless applications but also extends its capabilities to emulate various other services, thereby enriching our local development environment.

Check out my previous post

Code Anywhere: Configure Your Personal Web-Based Code Editor with AWS CLI or AWS CDK

Jimmy for AWS Community Builders ・ Oct 31

#aws #cli #cdk #lightsail

Unlocking the Power of NoSQL: Building a Todo API with Hapi.js and DynamoDB

Jimmy — Tue, 17 Oct 2023 06:16:37 +0000

In this article, we will explore how to build a Todo API service with Hapi.js and harnessing the power of Amazon DynamoDB as a serverless NoSQL database provided by AWS

DynamoDB

Amazon DynamoDB is a managed NoSQL database service provided by Amazon Web Services (AWS). It is designed for applications that require seamless and fast performance at any scale. DynamoDB is known for its high availability, durability, and scalability, making it suitable for a wide range of use cases, including web and mobile applications, gaming, IoT (Internet of Things), and more.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

Hapi.js

Hapi.js commonly referred to as "hapi," is an open-source web application framework for building web and application server systems in Node.js. It was created by Walmart Labs and is designed to provide a flexible and robust foundation for building web applications, APIs, and other networked software.

Prerequisites

Before we dive into the implementation, make sure you have the following prerequisites in place:

Install AWS CLI: You can install the AWS Command Line Interface by following the official documentation.

Make sure that your AWS CLI is already installed by running this command and it should return the respective output.

$ aws --version
aws-cli/2.13.23 Python/3.11.5 Windows/10 exe/AMD64 prompt/off

Configure AWS CLI: After installation, configure your AWS CLI,then run the following command and ensuring it returns your user information:

$ aws sts get-caller-identity
{
    "UserId": "YOUR-USER-ID",
    "Account": "YOUR-ACCOUNT-ID",
    "Arn": "arn:aws:iam::YOUR-ACCOUNT-ID:user/YOUR-USER-NAME"
}

Additionally, make sure you have the AdministratorAccess policy attached to your AWS CLI user by running:

$ aws iam list-attached-user-policies --user-name YOUR-USERNAME
{
    "AttachedPolicies": [
        {
            "PolicyName": "AdministratorAccess",
            "PolicyArn": "arn:aws:iam::aws:policy/AdministratorAccess"
        }
    ]
}

Obtain Access and Secret Keys
Project Preparation
Configure DynamoDB Client
Create DynamoDB Table
Create CRUD Handler
Register Handlers to Routes
Create Server and Register Route
Test the API
Cleanup
Conclusion

Obtain Access and Secret Keys

To obtain Access Key and Secret Key, follow these steps:

Create a User: You can create a new IAM user using the AWS CLI. (Replace YOUR-USERNAME with the desired username) :

$ aws iam create-user --user-name YOUR-USERNAME
{
    "User": {
        "Path": "/",
        "UserName": "YOUR-USERNAME",
        "UserId": "YOUR-USERID",
        "Arn": "arn:aws:iam::YOUR-ACCOUNTID:user/YOUR-USERNAME",
        "CreateDate": "2023-10-16T17:46:59+00:00"
    }
}

Create a DynamoDB CRUD Policy: Create a policy that defines the permissions for DynamoDB. You can use a JSON policy document like the one below and save it in a file (e.g. dynamodb-crud-policy.json).

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:PutItem",
        "dynamodb:GetItem",
        "dynamodb:UpdateItem",
        "dynamodb:DeleteItem",
        "dynamodb:Scan",
        "dynamodb:Query"
      ],
      "Resource": "*"
    }
  ]
}

Then create the policy using the AWS CLI:

$ aws iam create-policy --policy-name dynamodb-crud-policy --policy-document file://dynamodb-crud-policy.json
{
    "Policy": {
        "PolicyName": "dynamodb-crud-policy",
        "PolicyId": "XXXXXX",
        "Arn": "arn:aws:iam::YOUR-ACCOUNTID:policy/dynamodb-crud-policy",
        "Path": "/",
        "DefaultVersionId": "v1",
        "AttachmentCount": 0,
        "PermissionsBoundaryUsageCount": 0,
        "IsAttachable": true,
        "CreateDate": "2023-10-16T17:48:17+00:00",
        "UpdateDate": "2023-10-16T17:48:17+00:00"
    }
}

Attach the Policy to the User: Attach the DynamoDB CRUD policy to the IAM user you created earlier:

$ aws iam attach-user-policy --user-name your-username --policy-arn arn:aws:iam::YOUR-ACCOUNTID:policy/dynamodb-crud-policy

Generate Access Keys: You can generate access and secret access keys for the IAM user:

$ aws iam create-access-key --user-name your-username
{
    "AccessKey": {
        "UserName": "YOUR-USERNAME",
        "AccessKeyId": "YOUR-ACCESSID",
        "Status": "Active",
        "SecretAccessKey": "YOUR-SECRET-ACCESS-KEY",
        "CreateDate": "2023-10-16T17:49:44+00:00"
    }
}

This command will return the AccessKeyId and SecretAccessKey for your IAM user. Be sure to save these keys securely, as the secret access key will not be retrievable again.

Now you have created a user, attached a DynamoDB CRUD policy to that user, and generated access keys for them using the AWS CLI. Ensure you store these keys securely, as they provide access to your AWS resources.

Project Preparation

To set up our project, follow these steps:

Create a todoapp folder.
Initialize your project by running:

mkdir todoapp && cd todoapp
npm init -y

Install the required packages for your project using the following command:

npm install @hapi/hapi @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb dotenv

Create a .env file to store your environment variables, including your AWS credentials and other configuration settings. Here's an example of the content:

PORT=your_available_port
HOST=127.0.0.1

TABLE_NAME=your_table_name

AWS_REGION=your_aws_region
AWS_ACCESS_KEY_ID=your_access_key_id
AWS_SECRET_ACCESS_KEY=your_secret_access_key

Replace the placeholders (your_available_port, your_table_name, your_aws_region, your_access_key_id, and your_secret_access_key) with your actual values. The AWS credentials (access key and secret access key) are essential for your application to interact with DynamoDB and you can get it from previous step.

Configure DynamoDB Client

For DynamoDB client configuration, create a client.js file and include the following code:

const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");

exports.client = new DynamoDBClient({
  region: process.env.AWS_REGION,
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  },
});

This code exports a DynamoDB client object that can be used to interact with a DynamoDB table. The DynamoDBClient is imported from the @aws-sdk/client-dynamodb package.

The exports.client statement exports a new instance of the DynamoDBClient class. The constructor for the DynamoDBClient class takes an object with two properties: region and credentials. The region property is set to the value of the AWS_REGION environment variable. The credentials property is an object with two properties: accessKeyId and secretAccessKey. These properties are set to the values of the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables, respectively.

Create DynamoDB Table

To create your DynamoDB table using the AWS SDK, follow these steps:

Create a migrate.js file in your project and include the following code:

require("dotenv").config();
const { CreateTableCommand } = require("@aws-sdk/client-dynamodb");
const client = require("./client").client;

(async () => {
  try {
    const command = new CreateTableCommand({
      TableName: process.env.TABLE_NAME,
      AttributeDefinitions: [
        {
          AttributeName: "id",
          AttributeType: "S",
        },
      ],
      KeySchema: [
        {
          AttributeName: "id",
          KeyType: "HASH",
        },
      ],
      BillingMode: "PAY_PER_REQUEST",
    });

    const response = await client.send(command);
    return response;
  } catch (error) {
    console.error(error.message);
  }
})();

This code creates a DynamoDB table using the AWS SDK for JavaScript. It first imports the CreateTableCommand class from the @aws-sdk/client-dynamodb package and the client object from a local client.js file. The client object is an instance of the DynamoDBClient class, which is used to interact with DynamoDB.
The code then defines a new CreateTableCommand object, passing in an object with several properties. The TableName property is set to the value of the TABLE_NAME environment variable. The AttributeDefinitions property is an array of objects that define the attributes of the table. In this case, there is only one attribute, id, which is a string. The KeySchema property is an array of objects that define the primary key of the table. In this case, the primary key is the id attribute. The BillingMode property is set to "PAY_PER_REQUEST", which means that the table will be billed on a per-request basis.
The code then sends the CreateTableCommand to DynamoDB using the client.send() method. This method returns a promise that resolves to an object containing information about the table that was created.
If an error occurs during the execution of the code, the error message is logged to the console.

To run the create table code in migrate.js, you can run this command in your terminal.

node migrate.js

To check whether the table is created or not, you can run this AWS CLI command in your terminal. It should output a list of tables created in your DynamoDB.

$ aws dynamodb list-tables
{
    "TableNames": [
        "your_table_name"
    ]
}

Create CRUD Handler

Now, let's create the CRUD (Create, Read, Update, Delete) handlers for managing our todo items.

Create handlers.js, then start by typing this code :

const client = require("./client").client;
const {
  DynamoDBDocumentClient,
  PutCommand,
  UpdateCommand,
  QueryCommand,
  DeleteCommand,
  ScanCommand,
} = require("@aws-sdk/lib-dynamodb");

const docClient = DynamoDBDocumentClient.from(client);

const TableName = process.env.TABLE_NAME;

This code imports the client object from a local client.js file and several classes from the @aws-sdk/lib-dynamodb package. The imported classes are DynamoDBDocumentClient, PutCommand, UpdateCommand, QueryCommand, DeleteCommand, and ScanCommand. These classes are used to interact with a DynamoDB table.

The docClient object is created by calling the DynamoDBDocumentClient.from() method and passing in the client object. This creates a new instance of the DynamoDBDocumentClient class that is configured to use the client object to interact with DynamoDB.

The TableName constant is set to the value of the TABLE_NAME environment variable.

Still in handlers.js file, continue including following code below.

1. Create Add Todo Handler

const addTodo = async (request, h) => {
  const { title } = request.payload;

  try {
    const command = new PutCommand({
      TableName,
      Item: {
        id: Date.now().toString(),
        title: title,
        iscompleted: false,
      },
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(201);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named addTodo that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The function extracts the title property from the request.payload object, which contains the payload of the HTTP request. This property is used as the value of the title property in the object passed to the PutCommand constructor. The id property is set to the current timestamp converted to a string, which ensures that each todo item has a unique identifier.

The command object is created by calling the PutCommand constructor with an object that has two properties: TableName and Item. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The Item property is an object with three properties: id, title, and iscompleted. These properties are set to the values extracted from the request.payload object and the string "false", respectively.

The docClient.send() method is called with the command object, which sends a request to DynamoDB to add the item to the table. If the request is successful, the function returns an HTTP response with a status code of 201 and the response from DynamoDB as the response body. If an error occurs during the execution of the code, the error message is returned as an HTTP response.

2. Create Get All Todo Items Handler

const getTodos = async (request, h) => {
  try {
    const command = new ScanCommand({
      TableName,
    });

    const response = await docClient.send(command);
    return h
      .response({
      status: "success",
      message: response.Items
    })
      .code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named getTodos that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The function creates a new ScanCommand object with an object that has two properties: TableName and Limit. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The Limit property is set to 1, which means that only one item will be returned in the response.

The docClient.send() method is called with the command object, which sends a request to DynamoDB to scan the table for items. If the request is successful, the function returns an HTTP response with a status code of 200 and an object containing the items returned by the scan as the response body. If an error occurs during the execution of the code, the error message is returned as an HTTP response.

3. Create Get Todo Item by Id Handler

const getTodo = async (request, h) => {
  const { id } = request.params;

  try {
    const command = new QueryCommand({
      TableName,
      KeyConditionExpression: "id = :id",
      ExpressionAttributeValues: {
        ":id": id,
      },
    });

    const response = (await docClient.send(command)).Items[0];
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named getTodo that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The function extracts the id property from the request.params object, which contains the parameters of the HTTP request. The id property is used as the value of the :id placeholder in the KeyConditionExpression.

The command object is created by calling the QueryCommand constructor with an object that has several properties. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The KeyConditionExpression property is a string that specifies the condition that the item must meet to be returned. In this case, the id attribute must be equal to the value of the :id placeholder. The ExpressionAttributeValues property is an object that maps placeholder names to the values that will be substituted for them in the KeyConditionExpression. In this case, the :id placeholder is mapped to the value extracted from the request.params object.

The docClient.send() method is called with the command object, which sends a request to DynamoDB to query the table for items that meet the specified condition. If the request is successful, the function returns an HTTP response with a status code of 200 and the first item that matches the query as the response body. If no items match the query, the response body will be undefined. If an error occurs during the execution of the code, the error message is returned as an HTTP response.

4. Create Update Todo Item Handler

const updateTodo = async (request, h) => {
  const { id } = request.params;
  const { title } = request.payload;

  try {
    const command = new UpdateCommand({
      TableName,
      Key: {
        id: id,
      },
      UpdateExpression: "set title = :title",
      ExpressionAttributeValues: {
        ":title": title,
      },
      ReturnValues: "UPDATED_NEW",
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named updateTodo that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The function extracts the id property from the request.params object, which contains the parameters of the HTTP request. The id property is used as the value of the Key.id property in the object passed to the UpdateCommand constructor. The title property is extracted from the request.payload object, which contains the payload of the HTTP request. This property is used as the value of the :title placeholder in the UpdateExpression.

The command object is created by calling the UpdateCommand constructor with an object that has several properties. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The Key property is an object with one property: id. This property is set to the value extracted from the request.params object. The UpdateExpression property is a string that specifies the update to be made to the item. In this case, the title attribute is set to the value of the title property extracted from the request.payload object. The ExpressionAttributeValues property is an object that maps placeholder names to the values that will be substituted for them in the UpdateExpression. In this case, the :title placeholder is mapped to the value of the title property extracted from the request.payload object. The ReturnValues property specifies which attributes of the updated item should be returned in the response.

The docClient.send() method is called with the command object, which sends a request to DynamoDB to update the item with the specified id value. If the request is successful, the function returns an HTTP response with a status code of 200 and the updated item as the response body. If an error occurs during the execution of the code, the error message is returned as an HTTP response.

5. Create Update Todo Item Status IsCompleted Handler

const updateCompleted = async (request, h) => {
  const { id } = request.params;

  try {
    const command = new UpdateCommand({
      TableName,
      Key: {
        id: id,
      },
      UpdateExpression: "set iscompleted = :iscompleted",
      ExpressionAttributeValues: {
        ":iscompleted": true,
      },
      ReturnValues: "UPDATED_NEW",
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named updateCompleted that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The command object is created by calling the UpdateCommand constructor with an object that has several properties. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The Key property is an object with one property: id. This property is set to the value extracted from the request.params object. The UpdateExpression property is a string that specifies the update to be made to the item. In this case, the iscompleted attribute is set to true. The ExpressionAttributeValues property is an object that maps placeholder names to the values that will be substituted for them in the UpdateExpression. In this case, the :iscompleted placeholder is mapped to the value true. The ReturnValues property specifies which attributes of the updated item should be returned in the response.

6. Create Delete Todo Item Handler

const deleteTodo = async (request, h) => {
  const { id } = request.params;
  const command = new DeleteCommand({
    TableName,
    Key: {
      id: id,
    },
  });

  try {
    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: "Delete Todo Success"
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

This code defines an asynchronous function named deleteTodo that takes a request object and an h object as arguments. The request object contains information about the HTTP request that was made, and the h object contains methods for constructing an HTTP response.

The command object is created by calling the DeleteCommand constructor with an object that has two properties: TableName and Key. The TableName property is set to the value of the TableName constant, which is defined elsewhere in the code. The Key property is an object with one property: id. This property is set to the value extracted from the request.params object.

The docClient.send() method is called with the command object, which sends a request to DynamoDB to delete the item with the specified id value. If the request is successful, the function returns an HTTP response with a status code of 200 and a message indicating that the todo has been successfully deleted. If an error occurs during the execution of the code, the error message is returned as an HTTP response.

7. Export all the functions

module.exports = {
  addTodo,
  getTodos,
  getTodo,
  updateTodo,
  deleteTodo,
  updateCompleted,
};

This code exports an object with several functions that can be used to handle HTTP requests. The functions are named addTodo, getTodos, getTodo, updateTodo, deleteTodo, and updateCompleted.

The complete code of handlers.js will look like this.

const client = require("./client").client;
const {
  DynamoDBDocumentClient,
  PutCommand,
  UpdateCommand,
  QueryCommand,
  DeleteCommand,
  ScanCommand,
} = require("@aws-sdk/lib-dynamodb");

const docClient = DynamoDBDocumentClient.from(client);

const TableName = process.env.TABLE_NAME;

const addTodo = async (request, h) => {
  const { title } = request.payload;

  try {
    const command = new PutCommand({
      TableName,
      Item: {
        id: Date.now().toString(),
        title: title,
        iscompleted: false,
      },
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(201);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

const getTodos = async (request, h) => {
  try {
    const command = new ScanCommand({
      TableName,
    });

    const response = await docClient.send(command);
    return h
      .response({
      status: "success",
      message: response
    })
      .code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

const getTodo = async (request, h) => {
  const { id } = request.params;

  try {
    const command = new QueryCommand({
      TableName,
      KeyConditionExpression: "id = :id",
      ExpressionAttributeValues: {
        ":id": id,
      },
    });

    const response = (await docClient.send(command)).Items[0];
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

const updateTodo = async (request, h) => {
  const { id } = request.params;
  const { title } = request.payload;

  try {
    const command = new UpdateCommand({
      TableName,
      Key: {
        id: id,
      },
      UpdateExpression: "set title = :title",
      ExpressionAttributeValues: {
        ":title": title,
      },
      ReturnValues: "UPDATED_NEW",
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

const updateCompleted = async (request, h) => {
  const { id } = request.params;

  try {
    const command = new UpdateCommand({
      TableName,
      Key: {
        id: id,
      },
      UpdateExpression: "set iscompleted = :iscompleted",
      ExpressionAttributeValues: {
        ":iscompleted": true,
      },
      ReturnValues: "UPDATED_NEW",
    });

    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: response
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

const deleteTodo = async (request, h) => {
  const { id } = request.params;
  const command = new DeleteCommand({
    TableName,
    Key: {
      id: id,
    },
  });

  try {
    const response = await docClient.send(command);
    return h.response({
      status: "success",
      message: "Delete Todo Success"
    }).code(200);
  } catch (error) {
    return h.response({
      message: error.message,
    });
  }
};

module.exports = {
  addTodo,
  getTodos,
  getTodo,
  updateTodo,
  deleteTodo,
  updateCompleted,
};

Register Handlers to Routes

Now, let's register the handlers to Hapi.js routes.

Create a routes.js file and include the following code:

const todoHandler = require("./handlers");

exports.routes = [
  {
    method: "POST",
    path: "/todos",
    handler: todoHandler.addTodo,
  },
  {
    method: "GET",
    path: "/todos",
    handler: todoHandler.getTodos,
  },
  {
    method: "GET",
    path: "/todos/{id}",
    handler: todoHandler.getTodo,
  },
  {
    method: "PUT",
    path: "/todos/{id}",
    handler: todoHandler.updateTodo,
  },
  {
    method: "DELETE",
    path: "/todos/{id}",
    handler: todoHandler.deleteTodo,
  },
  {
    method: "PUT",
    path: "/todos/{id}/completed",
    handler: todoHandler.updateCompleted,
  },
];

This codes exports an array of objects that define the routes for a RESTful API. Each object in the array represents a single route and contains the following properties:

method: The HTTP method for the route (e.g. GET, POST, PUT, DELETE).
path: The URL path for the route.
handler: The function that will handle the request for the route.

The handler property is set to a function that is imported from a module named todoHandler.

Create Server and Register Route

To create the Hapi.js server and register the routes, follow these steps:

Create an index.js file in your project and include the following code:

require("dotenv").config();
const Hapi = require("@hapi/hapi");

const { routes } = require("./routes");

(async () => {
  const server = Hapi.server({
    port: process.env.PORT,
    host: process.env.HOST,
  });

  server.route(routes);

  await server.start();
  console.log("Server running on %s", server.info.uri);
})();

This code sets up a Hapi server that listens for incoming HTTP requests. It first loads environment variables from a .env file using the dotenv package. The Hapi package is then imported, which provides a framework for building HTTP servers in Node.js.
The routes object is imported from a separate file named routes.js. This object contains the routes that the server will handle.
An asynchronous function is defined using an immediately invoked function expression (IIFE) that creates a new instance of the Hapi.server class. The port and host properties of the server are set to the values of the PORT and HOST environment variables, respectively.
The server.route() method is called with the routes object, which sets up the routes that the server will handle.
The server.start() method is called to start the server. If the server starts successfully, a message is logged to the console indicating the URL that the server is listening on.

Test the API

To test the API, you can follow these steps:

Run the server

node index.js

Add Todo

$ curl -X POST http://localhost:8080/todos -H 'Content-Type: application/json' -d '{"title":"Build API with DynamoDB"}'

{"$metadata":{"httpStatusCode":200,"requestId":"cb51867a-2e1e-4d62-8ce6-f709825d2505","attempts":1,"totalRetryDelay":0}}

Get All Todo Item

$ curl -X GET http://localhost:8080/todos -H 'Content-Type: application/json' 

{"response":[{"title":"Build API with DynamoDB","iscompleted":false,"id":"1697484371663"}]}

Get Todo Item by Id

$ curl -X GET http://localhost:8080/todos/1697484371663 -H 'Content-Type: application/json'

{"title":"Build API with DynamoDB","iscompleted":false,"id":"1697484371663"}

Update Todo Item status IsCompleted

$ curl -X PUT http://localhost:8080/todos/1697484371663/completed -H 'Content-Type: application/json'

{"$metadata":{"httpStatusCode":200,"requestId":"b13129b1-1087-4e07-b205-60e067938327","attempts":1,"totalRetryDelay":0},"Attributes":{"iscompleted":true}}

Delete Todo Item

$ curl -X DELETE http://localhost:8080/todos/1697484371663 -H 'Content-Type: application/json'

Delete Todo Success

Cleanup

For cleanup, we can delete our DynamoDB table that we created before by typing this command in our terminal.

$ aws dynamodb delete-table --table-name your_table_name
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "id",
                "AttributeType": "S"
            }
        ],
        "TableName": "your_table_name",
        "KeySchema": [
            {
                "AttributeName": "id",
                "KeyType": "HASH"
            }
        ],

Conclusion

In this blog post, we learn about building a Todo API using the powerful Hapi.js framework and harnessing the capabilities of Amazon DynamoDB. Throughout this tutorial, we've seen how these two technologies can be seamlessly integrated to create a robust and scalable solution for managing tasks and to-do lists.

Hapi.js, with its ease of use and extensive ecosystem of plugins, provided us with a solid foundation to build our API. Its routing, validation, and error-handling capabilities make it an excellent choice for developing RESTful services. Moreover, we appreciated the emphasis on configuration-driven development, which simplifies the setup process and enhances maintainability.

DynamoDB, Amazon's fully managed NoSQL database, proved to be a valuable asset in our project. Its scalability, high availability, and serverless architecture ensured that our Todo API can handle both small-scale tasks and grow seamlessly to accommodate larger workloads. The performance and durability of DynamoDB, combined with features like automatic backups and global tables, give us peace of mind when it comes to data integrity.

In conclusion, building a Todo API with Hapi.js and DynamoDB is a rewarding experience that equips you with the tools to create powerful, scalable, and resilient applications.

Check out my previous post

Generate Image from Text Using Amazon Bedrock's Stable Diffusion XL Model via AWS CLI

Jimmy for AWS Community Builders ・ Oct 9 '23

#aws #generativeai #amazonbedrock

Generate Image from Text Using Amazon Bedrock's Stable Diffusion XL Model via AWS CLI

Jimmy — Mon, 09 Oct 2023 19:36:59 +0000

In this article, we will learn another way to invoke Amazon Bedrock's Model using AWS Command Line Interface (CLI).

We are going to generate an image from a text prompt using Amazon Bedrock's Stable DIffusion XL Model via AWS CLI.

From this text prompt

the quick brown fox jumps over the lazy dog

to this generated image by Amazon Bedrock.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

Amazon Bedrock

Amazon Bedrock is a fully managed service from Amazon Web Services that provides access to foundation models from Amazon and select third-party providers through a simple API. It allows customers to easily choose from a wide range of foundation models to find the one best suited for their use case. With Amazon Bedrock, customers can quickly get started with these models, privately customize them using their own data, and integrate them into applications. The service handles all infrastructure management so customers can focus on using the models without having to worry about deployment or maintenance. Amazon Bedrock also integrates with other Amazon Web Services like Amazon SageMaker for capabilities such as model testing and lifecycle management.

Prerequisites Tools

Create an IAM User with Amazon Bedrock Invoke Model Policy
Create User Access Keys
Configure AWS CLI
Enable Amazon Bedrock Model Access
Create Text Prompt
Invoke Amazon Bedrock's Stable Diffusion XL Model
Conclusion

Create an IAM User with Amazon Bedrock Invoke Model Policy

From AWS Management Console search IAM
Go to user menu and click Create User
Specify user detail then click Next
Create Policy
Specify Permission
Review and Create Policy

Create User Access Keys

Go to Security Credentials
Choose the access key use case
Set Descriptions
Copy Access Key and Secret access key or you can download in a csv format then click done

Enable Amazon Bedrock Model Access

Go to Amazon Bedrock in AWS Management Console (make sure you are in N.Virginia (us-east-1) region.
Go to Model access menu then click Edit.

Check list Stability AI model and click save changes

Configure AWS CLI

Configure AWS CLI with the Access Key and Secret Access key that you created before using aws configure command in your terminal.

$ aws configure
AWS Access Key ID [****************T7JE]: xxxxxx
AWS Secret Access Key [****************153Y]: xxxxx
Default region name [ap-southeast-1]: us-east-1
Default output format [json]: json

Create Text Prompt

We will create a file body.json that contains a text prompt and some model controls that we are going to use to invoke Amazon Bedrock Model.

{
  "text_prompts": [{ "text": "the quick brown fox jumps over the lazy dog" }],
  "cfg_scale": 10,
  "seed": 0,
  "steps": 50
}

The Stability.ai Diffusion models support the following controls.

Prompt strength (cfg_scale) – Determines how much the final image portrays the prompt. Use a lower number to increase randomness in the generation.

Generation step (steps) – Generation step determines how many times the image is sampled. More steps can result in a more accurate result.

Seed (seed) – The seed determines the initial noise setting. Use the same seed and the same settings as a previous run to allow inference to create a similar image. If you don't set this value, it is set as a random number.

Invoke Amazon Bedrock's Stable Diffusion XL Model

Invoke Amazon Bedrock model using command below and then output it into bedrock-response.json

aws bedrock-runtime invoke-model \
--body "$(base64 -i body.json)" \
--model-id "stability.stable-diffusion-xl-v0" \
--region us-east-1
bedrock-response.json

Amazon Bedrock will output the image in base64 format into bedrock-response.json

{"result":"success","artifacts":[{"seed":0,"base64":"iVBORw0KGgoAAA.......","finishReason":"SUCCESS"}]}

So we need to filter out the base64 part from bedrock-response.json, then output it into a file base64.txt

cat bedrock-response.json | jq -r ".artifacts[0].base64" > base64.txt

Last, Decode base64.txt file into image-result.png

cat base64.txt | base64 -d > image-result.png

You should get image-result.png file with this image

Conclusion

From this article, we learn that we have the option to utilize the Amazon Bedrock model not only through the AWS-SDK but also directly via AWS-CLI from our terminal.

Check out my previous post

Build Serverless Generative AI API Service with AWS Lambda and Amazon Bedrock

Jimmy for AWS Community Builders ・ Oct 2 '23

#aws #serverless #generativeai #node

Build Serverless Generative AI API Service with AWS Lambda and Amazon Bedrock

Jimmy — Mon, 02 Oct 2023 10:38:03 +0000

In this article, we'll guide you through the process of constructing a Generative AI API Service using AWS Serverless Application Model (SAM). We'll then demonstrate how to deploy it to AWS Lambda, leveraging the robust capabilities of Amazon Bedrock for a powerful and scalable solution.

We will create an API endpoint like this

https://hwnfnespxzpw7pkz2ydjuwskpq0fokxv.lambda-url.ap-southeast-1.on.aws/

and then send POST request to that endpoint with our prompt question explain to me about AWS Lambda? as payload

curl -k \
> -X POST \
> -H 'Content-Type: application/json' \
> -d '{"prompt":"explain to me about AWS Lambda"}' \
> https://hwnfnespxzpw7pkz2ydjuwskpq0fokxv.lambda-url.ap-southeast-1.on.aws/

Then get a response like this generated by Amazon Bedrock

{"message":"\nAWS Lambda is a serverless computing service provided by Amazon Web Services (AWS). It allows users to run code in response to events, without the need for them to provision or manage servers. With Lambda, you can create and run code without thinking about servers.\n\nLambda is designed to run code in response to events, such as a file in an Amazon Simple Storage Service (Amazon S3) bucket being modified, or a table being updated in an Amazon DynamoDB table. Lambda automatically manages the computing resources required to execute the functions, and scales them as needed.\n\nTo use Lambda, you first create a function by writing code in Node.js, Java, Python, or Ruby. You can then configure triggers that invoke the function when an event occurs. Lambda also allows you to configure how much memory and time the function should use when it is invoked.\n\nLambda functions can run for a maximum of 15 minutes, and are charged based on a pricing model that calculates the amount of time and resources consumed by the function when it is invoked. This means that you only pay for the actual compute time used by your function, and not for idle time.\n\nOverall, Lambda is a powerful tool that allows you to run code in the cloud without having to worry about the underlying infrastructure."}

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

Amazon Bedrock

Prerequisites
Enable Amazon Bedrock Model Access
Prepare AWS SAM Project
Prepare Lambda function code
Deploy your SAM project
Cleanup

Prerequisites Tools

Enable Amazon Bedrock Model Access

In order to utilize the Amazon Bedrock foundation model, you must activate model access, which is currently exclusively accessible in the us-east-1 (N. Virginia) region through the AWS Management Console.

Check list the model that you want to use and then click Save changes

Prepare AWS SAM Project

To prepare your AWS SAM project, start by creating a lambda-bedrock folder. Inside lambda-bedrock folder then create your AWS SAM template template.yaml.

mkdir lambda-bedrock
cd lambda-bedrock
touch template.yaml

These commands create a new directory called lambda-bedrock, navigate into that directory, and create a new file called template.yaml. The mkdir command creates the directory, the cd command navigates into that directory, and the touch command creates the new file. This is a common set of commands used to create a new project directory and file.

Then define your resources inside template.yaml

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: >
  lambda-bedrock

  Sample SAM Template for lambda-bedrock


Resources:
  BedrockFunction:
    Type: AWS::Serverless::Function
    Region: us-east-1
    Properties:
      Timeout: 30
      CodeUri: src/
      Handler: app.handler
      Runtime: nodejs18.x
      FunctionUrlConfig:
        AuthType: NONE
        InvokeMode: BUFFERED
      Policies:
        - Statement:
            - Effect: Allow
              Action: bedrock:InvokeModel
              Resource: "arn:aws:bedrock:us-east-1::foundation-model/ai21.j2-ultra-v1"

Outputs:
  FunctionUrlEndpoint:
    Description: "Lambda Bedrock URL Endpoint"
    Value:
      Fn::GetAtt: BedrockFunctionUrl.FunctionUrl

This is a CloudFormation template that defines an AWS Lambda function using the AWS::Serverless::Function resource type. The BedrockFunction resource is defined with the specified properties.

The Type field specifies the resource type, which is AWS::Serverless::Function. This resource type is used to define a serverless function that can be executed in response to an event.

The Region field specifies the AWS region where the function will be created. In this case, it is set to us-east-1.

The Properties field contains the properties that define the function. The Timeout property specifies the maximum amount of time that the function can run before it times out. In this case, it is set to 30 seconds.

The CodeUri property specifies the location of the function's code. In this case, it is set to src/, which indicates that the code is located in the src directory.

The Handler property specifies the name of the function's handler method. In this case, it is set to app.handler, which indicates that the handler method is located in the app.js file.

The Runtime property specifies the runtime environment that the function will use. In this case, it is set to nodejs18.x, which indicates that the function will run on Node.js version 18.x.

The FunctionUrlConfig property specifies the configuration for the function's URL. The AuthType property specifies the authentication type that will be used to access the function. In this case, it is set to NONE, which indicates that no authentication is required. The InvokeMode property specifies the mode in which the function will be invoked. In this case, it is set to BUFFERED, which indicates that the function will be invoked in buffered mode.

The BedrockInvokeModelPolicy resource defines an IAM policy that allows invoking a machine learning model. The policy is attached to an existing IAM role and applies to the specified machine learning model arn:aws:bedrock:us-east-1::foundation-model/ai21.j2-ultra-v1.

The Outputs field contains a list of output values that are exported by the CloudFormation stack. In this case, there is only one output value. The FunctionUrlEndpoint output value retrieves the URL of the BedrockFunctionUrl resource.

Prepare Lambda function code

mkdir src
touch src/app.js
cd src
npm init -y
npm install aws-sdk

These commands create a new directory called src, navigate into that directory, create a new file called index.js, initialize a new Node.js project with default settings using npm init -y, and install the aws-sdk package using npm install aws-sdk.

The mkdir command creates the src directory, the touch command creates the app.js file inside the src directory, the cd command navigates into the src directory, the npm init -y command initializes a new Node.js project with default settings, and the npm install aws-sdk command installs the aws-sdk package as a dependency for the project.

Inside app.js

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

const bedrockRuntime = new AWS.BedrockRuntime({
  apiVersion: "2023-09-30",
  region: "us-east-1",
});

async function invokeModel(prompt) {
  try {
    const response = await new Promise((resolve, reject) => {
      bedrockRuntime.invokeModel(
        {
          modelId: "ai21.j2-ultra-v1",
          contentType: "application/json",
          accept: "*/*",
          body: JSON.stringify({
            prompt: prompt,
            maxTokens: 1000,
            temperature: 0.9,
          }),
        },
        function (err, data) {
          if (err) {
            console.log(err, err.stack);
            reject(err);
          } else {
            const response = JSON.parse(data.body);
            resolve(response.completions[0].data.text);
          }
        }
      );
    });

    return response;
  } catch (err) {
    console.log(err);
  }
}

exports.handler = async (event, context) => {
  const { prompt } = JSON.parse(event.body);

  const response = await invokeModel(prompt);

  try {
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: response,
      }),
    };
  } catch (err) {
    console.log(err);
  }
};

This is a Node.js module that defines an AWS Lambda function that invokes a machine learning model using the BedrockRuntime class from the aws-sdk package. The handler function is exported as the entry point for the Lambda function.

The require function is used to import the aws-sdk package, which provides a JavaScript interface for interacting with AWS services. The BedrockRuntime class is used to invoke the machine learning model.

The invokeModel function is defined to invoke the machine learning model with the specified prompt. The function sends a request to the BedrockRuntime service with the specified parameters, including the model ID, content type, and request body. The function returns the response from the service, which includes the completed text generated by the machine learning model.

The handler function is defined as the entry point for the Lambda function. The function receives an event object and a context object as parameters. The event object contains the request data, including the prompt. The context object contains information about the execution environment.

The handler function parses the prompt from the request data and passes it to the invokeModel function. The function then returns a response object with a status code of 200 and a message containing the completed text generated by the machine learning model.

Deploy your SAM project

sam build
sam deploy --guided --region us-east-1

These commands use the AWS Serverless Application Model (SAM) to build and deploy the Lambda function defined in the app.js file to the us-east-1 region.

The sam build command builds the application and prepares it for deployment. This command uses the template.yaml file to determine the build configuration.

The sam deploy command deploys the application to AWS. The --guided option prompts the user for configuration settings, such as the stack name and deployment bucket (you only need this for the first time deployment, for subsequent deploy just run sam deploy). The --region option specifies the AWS region where the application will be deployed.

You will be prompt with this input

        Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [lambda-bedrock]:
        AWS Region [us-east-1]:
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [Y/n]:
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]:
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]:
        BedrockFunction Function Url has no authentication. Is this okay? [y/N]: y
        Save arguments to configuration file [Y/n]:
        SAM configuration file [samconfig.toml]:
        SAM configuration environment [default]: dev

Then followed by this Initiating deployment confirmation

Initiating deployment
=====================

        Uploading to lambda-bedrock/5dd89a16d669f1bc7ef501c1a740d0fb.template  1185 / 1185  (100.00%)


Waiting for changeset to be created..

CloudFormation stack changeset
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------    
Operation                                                 LogicalResourceId                                         ResourceType                                              Replacement
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------    
+ Add                                                     BedrockFunctionRole                                       AWS::IAM::Role                                            N/A
+ Add                                                     BedrockFunctionUrlPublicPermissions                       AWS::Lambda::Permission                                   N/A
+ Add                                                     BedrockFunctionUrl                                        AWS::Lambda::Url                                          N/A
+ Add                                                     BedrockFunction                                           AWS::Lambda::Function                                     N/A
+ Add                                                     BedrockInvokeModelPolicy                                  AWS::IAM::Policy                                          N/A
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------    


Changeset created successfully. arn:aws:cloudformation:ap-southeast-1:498624870591:changeSet/samcli-deploy1696242138/3e3a06d0-33c5-46cb-ad69-56edea2d1321


Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]:

After your deployment completed, you will get output like this

CloudFormation outputs from deployed stack
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
Outputs
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
Key                 FunctionUrlEndpoint
Description         Lambda Bedrock URL Endpoint
Value               https://hwnfnespxzpw7pkz2ydjuwskpq0fokxv.lambda-url.ap-southeast-1.on.aws/

You can then take that Lambda endpoint and test sending your prompt like this

curl -k \
> -X POST \
> -H 'Content-Type: application/json' \
> -d '{"prompt":"explain to me about AWS Lambda"}' \
> https://hwnfnespxzpw7pkz2ydjuwskpq0fokxv.lambda-url.ap-southeast-1.on.aws/

Then you will get response from your Lambda like this

{"message":"\nAWS Lambda is a serverless computing service provided by Amazon Web Services (AWS). It allows users to run code in response to events, without the need for them to provision or manage servers. With Lambda, you can create and run code without thinking about servers.\n\nLambda is designed to run code in response to events, such as a file in an Amazon Simple Storage Service (Amazon S3) bucket being modified, or a table being updated in an Amazon DynamoDB table. Lambda automatically manages the computing resources required to execute the functions, and scales them as needed.\n\nTo use Lambda, you first create a function by writing code in Node.js, Java, Python, or Ruby. You can then configure triggers that invoke the function when an event occurs. Lambda also allows you to configure how much memory and time the function should use when it is invoked.\n\nLambda functions can run for a maximum of 15 minutes, and are charged based on a pricing model that calculates the amount of time and resources consumed by the function when it is invoked. This means that you only pay for the actual compute time used by your function, and not for idle time.\n\nOverall, Lambda is a powerful tool that allows you to run code in the cloud without having to worry about the underlying infrastructure."}

This response is generated by Amazon Bedrock from the prompt you send to your Lambda endpoint.

Cleanup

To delete all your resources that created using SAM Template, you can run this command

sam delete --region us-east-1
        Are you sure you want to delete the stack lambda-bedrock in the region us-east-1 ? [y/N]: y
        Do you want to delete the template file fbc4997de651419e130644091ddcceb5.template in S3? [y/N]: y
        - Deleting S3 object with key 3ba0b8c3b1f20b100cab919b0cf2291a
        - Deleting S3 object with key fbc4997de651419e130644091ddcceb5.template
        - Deleting Cloudformation stack lambda-bedrock

This command will cleanup all the resources for you.

Check out my previous post

Build serverless AWS announcements email service with AWS Application Composer and AWS SAM

Jimmy for AWS Community Builders ・ Dec 5 '22

#aws #serverless #javascript #node

Build serverless AWS announcements email service with AWS Application Composer and AWS SAM

Jimmy — Mon, 05 Dec 2022 20:28:30 +0000

In this post, we will build a serverless email service that can send the latest 24 hours AWS Announcements to your mailbox using AWS Application Composer and AWS Serverless Application Model (SAM) like this.

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Share about Web, Mobile, Backend, Frontend, and Cloud Computing.

linktr.ee

Prerequisites
AWS Application Composer
Amazon Event Bridge Schedule
AWS Step Functions
AWS Lambda Function
AWS DynamoDB
Amazon SES
The Code
- parseFeeds
- sendMail
Deployment
Test

Prerequisites

AWS Application Composer

Recently at AWS re:Invent 2022, AWS is launching a preview of AWS Application Composer, a visual designer that you can use to build your serverless applications from multiple AWS services.

We will use AWS Application Composer to design our serverless application service.

First, launch AWS Application Composer from your AWS Management console.

Then create new project with configurations like this.

Drag and drop the resources from the left side into the canvas until you get this workflow diagram

As you can see from the above diagram, we will be using several AWS services to build our serverless service.

We will be using

Amazon Event Bridge Schedule
AWS Step Functions
AWS Lambda
DynamoDB
AWS Simple Email Service

Amazon Event Bridge Schedule

Amazon EventBridge allows you to create, run, and manage scheduled tasks at scale.

We will use Amazon Event Bridge Schedule to invoke our step functions with these configurations

In this configuration, we will set cron expression to invoke our step functions every day at 7 AM with Asia/Jakarta timezone.

AWS Step Functions

AWS Step Functions provides serverless orchestration for modern applications. Orchestration centrally manages a workflow by breaking it into multiple steps, adding flow logic, and tracking the inputs and outputs between the steps.

We will use AWS Step Functions to orchestrate our lambda functions with these configurations

for the state machine definitions, we will configure it like this so that we can invoke parseFeeds Lambda function and then sendMail Lambda function.

StartAt: Start
States:
  Start:
    Type: Pass
    Next: parseFeeds
  parseFeeds:
    Type: Task
    Next: sendMail
    Resource: arn:aws:states:::lambda:invoke
    Parameters:
      FunctionName: ${parseFeedsArn}
      Payload.$: $
  sendMail:
    Type: Task
    Next: Done
    Resource: arn:aws:states:::lambda:invoke
    Parameters:
      FunctionName: ${sendMailArn}
      Payload.$: $
  Done:
    Type: Pass
    End: true

AWS Lambda Function

AWS Lambda is a serverless compute service that runs your code in response to events and automatically manages the underlying compute resources for you.

We will create two lambda functions, one for parsing AWS announcements RSS feeds and saving them to DynamoDB (parseFeeds) and the other one for sending last 24 hours' AWS announcements from DynamoDB and sending it to your mailbox (sendMail).

for parseFeeds lambda function, we will configure it this way

then for sendMail lambda function, we configure it this way

AWS DynamodDB

Fast, flexible NoSQL database service for single-digit millisecond performance at any scale

We will use DynamoDB to save the last 24 hours AWS Announcement from parseFeed lambda function and then get those items and send them to your email from sendMail lambda function.

Our DynamoDB will be configured this way

We will configure guid as partition key, then isodate as sort key, then we set expiration key so that DynamoDB will delete the record with expiration TTL above 30 minutes (because we don't need the data anymore after successfully send to your email to save Dynamodb cost)

After finishing configuring your resources, you can save your AWS Application Composer project into the project folder on your local computer as template.yml from Menu > Save changes

Your template.yml should look like this

Transform: AWS::Serverless-2016-10-31
Resources:
  StateMachine:
    Type: AWS::Serverless::StateMachine
    Properties:
      Definition:
        StartAt: Start
        States:
          Start:
            Type: Pass
            Next: parseFeeds
          parseFeeds:
            Type: Task
            Next: sendMail
            Resource: arn:aws:states:::lambda:invoke
            Parameters:
              FunctionName: ${parseFeedsArn}
              Payload.$: $
          sendMail:
            Type: Task
            Next: Done
            Resource: arn:aws:states:::lambda:invoke
            Parameters:
              FunctionName: ${sendMailArn}
              Payload.$: $
          Done:
            Type: Pass
            End: true
      Logging:
        Level: ALL
        IncludeExecutionData: true
        Destinations:
          - CloudWatchLogsLogGroup:
              LogGroupArn: !GetAtt StateMachineLogGroup.Arn
      Policies:
        - AWSXrayWriteOnlyAccess
        - Statement:
            - Effect: Allow
              Action:
                - logs:CreateLogDelivery
                - logs:GetLogDelivery
                - logs:UpdateLogDelivery
                - logs:DeleteLogDelivery
                - logs:ListLogDeliveries
                - logs:PutResourcePolicy
                - logs:DescribeResourcePolicies
                - logs:DescribeLogGroups
              Resource: '*'
        - LambdaInvokePolicy:
            FunctionName: !Ref parseFeeds
        - LambdaInvokePolicy:
            FunctionName: !Ref sendMail
      Tracing:
        Enabled: true
      Type: STANDARD
      DefinitionSubstitutions:
        parseFeedsArn: !GetAtt parseFeeds.Arn
        sendMailArn: !GetAtt sendMail.Arn
  StateMachineLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub
        - /aws/vendedlogs/states/${AWS::StackName}-${ResourceId}-Logs
        - ResourceId: StateMachine
  parseFeeds:
    Type: AWS::Serverless::Function
    Properties:
      Description: !Sub
        - Stack ${AWS::StackName} Function ${ResourceName}
        - ResourceName: parseFeeds
      CodeUri: src/Function
      Handler: index.handler
      Runtime: nodejs16.x
      MemorySize: 128
      Timeout: 30
      Tracing: Active
      Environment:
        Variables:
          TABLE_NAME: !Ref Feeds
          TABLE_ARN: !GetAtt Feeds.Arn
      Policies:
        - DynamoDBWritePolicy:
            TableName: !Ref Feeds
  parseFeedsLogGroup:
    Type: AWS::Logs::LogGroup
    DeletionPolicy: Retain
    Properties:
      LogGroupName: !Sub /aws/lambda/${parseFeeds}
  sendMail:
    Type: AWS::Serverless::Function
    Properties:
      Description: !Sub
        - Stack ${AWS::StackName} Function ${ResourceName}
        - ResourceName: sendMail
      CodeUri: src/Function2
      Handler: index.handler
      Runtime: nodejs16.x
      MemorySize: 128
      Timeout: 60
      Tracing: Active
      Environment:
        Variables:
          TABLE_NAME: !Ref Feeds
          TABLE_ARN: !GetAtt Feeds.Arn
      Policies:
        - DynamoDBReadPolicy:
            TableName: !Ref Feeds
        - SESCrudPolicy:
            IdentityName:  example.com //Domain you will use to send email
        - SESCrudPolicy:
            IdentityName: example@email.com //email account you will use to receive the email in sandbox SES
  sendMailLogGroup:
    Type: AWS::Logs::LogGroup
    DeletionPolicy: Retain
    Properties:
      LogGroupName: !Sub /aws/lambda/${sendMail}
  Feeds:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: guid
          AttributeType: S
        - AttributeName: isodate
          AttributeType: S
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: guid
          KeyType: HASH
        - AttributeName: isodate
          KeyType: RANGE
      TimeToLiveSpecification:
        AttributeName: expiration
        Enabled: true
  SendMailEventSchedule:
    Type: AWS::Scheduler::Schedule
    Properties:
      ScheduleExpression: cron(0 7 * * ? *)
      FlexibleTimeWindow:
        Mode: 'OFF'
      ScheduleExpressionTimezone: Asia/Jakarta
      Target:
        Arn: !Ref StateMachine
        RoleArn: !GetAtt SendMailEventScheduleToStateMachineRole.Arn
  SendMailEventScheduleToStateMachineRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          Effect: Allow
          Principal:
            Service: !Sub scheduler.${AWS::URLSuffix}
          Action: sts:AssumeRole
          Condition:
            ArnLike:
              aws:SourceArn: !Sub
                - arn:${AWS::Partition}:scheduler:${AWS::Region}:${AWS::AccountId}:schedule/*/${AWS::StackName}-${ResourceId}-*
                - ResourceId: SendMailEventSchedule
      Policies:
        - PolicyName: StartExecutionPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action: states:StartExecution
                Resource: !Ref StateMachine

Amazon Simple Email Service

Amazon SES allow you to start sending email in minutes.

Notice in sendMail function resource above that we add several policies so that our function can send email through Amazon SES

- SESCrudPolicy:
    IdentityName:  example.com //Domain you will use to send email
- SESCrudPolicy:
    IdentityName: example@email.com //email account you will use to receive the email in sandbox SES

Makes sure you already create verified identities in Amazon SES for the domain to send email and the email account that you are going to use to receive email from Amazon SES (for sandbox SES) like this

The Code

parseFeeds functions

in your root project folder where you save your project template.yml, run this command (make sure you already install nodejs and npm before)

mkdir src src/Function
cd src/Function
npm init -y
npm install rss-parser
touch index.js

then copy and paste this code below into index.js

// import aws sdk
const AWS = require('aws-sdk');
AWS.config.update({region: 'ap-southeast-1'});

const docClient = new AWS.DynamoDB.DocumentClient({apiVersion: '2012-08-10'});

const parse = new (require('rss-parser'))();

exports.handler = async (event) => {
    const {items: feeds} = await  parse.parseURL("https://aws.amazon.com/about-aws/whats-new/recent/feed/");
    let parseCount = 0;

    try {
        await Promise.all(feeds
            .filter((feed) => new Date(feed.isoDate).getTime() >= Date.now() - 24 * 60 * 60 * 1000) //filter feeds with isodate last  24 hours
            .map(async (feed) => {
                const params = {
                    TableName: process.env.TABLE_NAME,
                    Item: {
                        "guid": feed.guid,
                        "isodate": feed.isoDate,
                        "title": feed.title,
                        "link": feed.link,
                        "description": feed.contentSnippet,
                        "expiration": Math.round(Date.now() / 1000) + 1800 //delete feeds after 30 minutes
                    }
                };

                await docClient.put(params).promise();
                parseCount++;
            }));

        return {
            statusCode: 200,
            headers: {
                "Content-Type": "application/json"
            },
            body: JSON.stringify({parseCount})
        };
    } catch (error) {
        console.log(error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({message: "Error parse feeds"})
        };
    }


}

sendMail function

in your root project folder again run this command

mkdir src/Function2
cd src/Function2
touch index.js

then copy and paste this code below into index.js

const AWS = require('aws-sdk');
AWS.config.update({region: 'ap-southeast-1'});

const dynamodb = new AWS.DynamoDB({apiVersion: "2012-08-10"});
const ses = new AWS.SES({ apiVersion: "2010-12-01" });

exports.handler = async (event) => {
    try {
        const {Items} = await dynamodb.scan({TableName: process.env.TABLE_NAME}).promise();
        if(Items.length > 0) {
            const params = {
              Destination: {
                ToAddresses: ["example@email.com"],
              },
              Message: {
                Body: {
                  Html: {
                    Charset: "UTF-8",
                    Data: "<h1>Today's AWSome Announcements</h1>" + Items.map(
                      (item) =>
                        `<a href='${item.link.S}'>${item.title.S}</a><p>${item.description.S}</p>`
                    ).join(""),
                  },
                },
                Subject: {
                  Charset: "UTF-8",
                  Data: "AWS Announcements",
                },
              },
              Source: "hello@example.com",
            };

            const {MessageId} = await ses.sendEmail(params).promise();

            return {
                statusCode: 200,
                headers: {
                    "Content-Type": "application/json"
                },
                body: JSON.stringify({MessageId}),
            };
        }else{
            throw new Error("No items found");
        }        
    } catch (error) {
        console.log(error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({message: "Error send email"})
        }
    }
}

Deployment

We will use SAM CLI to provision and deploy our serverless service, makes sure you already install AWS CLI and SAM CLI on your local computer and then configure AWS CLI before (check prerequisites).

First, we need to build our project with this command

sam build

you will get output like this

Building codeuri: runtime: nodejs16.x metadata: {} architecture: x86_64 functions: parseFeeds
Running NodejsNpmBuilder:NpmPack
Running NodejsNpmBuilder:CopyNpmrcAndLockfile
Running NodejsNpmBuilder:CopySource
Running NodejsNpmBuilder:NpmInstall
Running NodejsNpmBuilder:CleanUpNpmrc
Running NodejsNpmBuilder:LockfileCleanUp
Building codeuri: runtime: nodejs16.x metadata: {} architecture: x86_64 functions: sendMail
package.json file not found. Continuing the build without dependencies.
Running NodejsNpmBuilder:CopySource

Build Succeeded

Built Artifacts  : .aws-sam\build
Built Template   : .aws-sam\build\template.yaml

Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {stack-name} --watch
[*] Deploy: sam deploy --guided

then you can start for first time deploy your serverless service with this command

sam deploy --guided

fill in the configuration below

Configuring SAM deploy
======================

        Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [mail-broadcast]: mail-broadcast
        AWS Region [ap-southeast-1]: ap-southeast-1
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [Y/n]: Y
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]: Y
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]: N
        Save arguments to configuration file [Y/n]: Y
        SAM configuration file [samconfig.toml]:  
        SAM configuration environment [default]:

then your serverless application will start deploying into your AWS account.

for the next deployment you just need to use this command

sam deploy

After successful deployment, you can check into your AWS management console and find out that we successfully provision all the AWS services and deploy our lambda functions.

Test

To test our serverless service without have to wait Amazon EventBridge schedule to invoke your step functions, you can invoke your step function by going to step functions menu in your AWS management console and start execution in your step function until it shows like this

If the execution is successful like above, you will receive an email like this in your email account that you already configure into Amazon SES(email will only be sent when there is AWS Announcement in the last 24 hours).

DEV Community: Jimmy

Utilize AI-powered Tools Amazon CodeWhisperer and Amazon Q in Visual Studio Code on Android Devices

Amazon CodeWhisperer

Amazon Q

Termux

Install and Configure Termux

Code Server (VS Code in the browser)

Install Code Server

Run Code Server

AWS Toolkit for Visual Studio Code

Install AWS Toolkit

Authenticating AWS Toolkit extension

Using Amazon Q

Using Amazon CodeWhisperer.

Add Code Server as an Application

Conclusions

Check out my other post

Stream Amazon Bedrock Response with AWS Lambda Response Streaming

Jimmy for AWS Community Builders ・ Nov 24 '23

Stream Amazon Bedrock Response with AWS Lambda Response Streaming

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

AWS Lambda

Amazon Bedrock

Prerequisites

Create AWS SAM project

Lambda Function Handler

SAM Template

Deploy AWS SAM project

Test

[BONUS] Stream Response to Browser

Cleanup

Conclusions

Check out my previous post

Local Serverless Application Development with AWS SAM and Localstack

Jimmy for AWS Community Builders ・ Oct 18 '23

References

Serverless Scheduled Reporting Service with AWS EventBridge, Lambda, SNS, and CDK

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

EventBridge (CloudWatch Events)

AWS Lambda

Amazon Simple Notification Service (SNS)

AWS Cloud Development Kit (CDK)

Prerequisites

Table of Contents

Create Project

Create Lambda handler

Create Stack

Import modules

Create Parameter

Create SNS Topic

Create Lambda Function

Permission to publish message to SNS Topic

Create EventBridge Schedule Rule

Trigger Lambda from EventBridge

Complete Stack Code

Deploy Stack

Testing

Conclusion

Check out my previous post

Unlocking the Power of NoSQL: Building a Todo API with Hapi.js and DynamoDB

Jimmy for AWS Community Builders ・ Oct 17 '23

Code Anywhere: Configure Your Personal Web-Based Code Editor with AWS CLI or AWS CDK

Follow me for more

fullstacksaiyan; | Twitter, Instagram, Facebook, TikTok | Linktree

Why Choose a Web-Based Code Editor?

Installer VS Code for the Web

Amazon Lightsail

Prerequisites

Table of Contents

Lightsail Resource Parameters

Configure Lightsail with AWS CLI

Configure Lightsail with AWS CDK

Conclusions

Check out my previous post

Unlocking the Power of NoSQL: Building a Todo API with Hapi.js and DynamoDB

Jimmy for AWS Community Builders ・ Oct 17 '23

Deploy & Run your Node.js Framework App on AWS Lambda with AWS Lambda Web Adapter

Follow me for more

Modify our `template.yaml` and function handlers

Install `samlocal`