DEV Community: Rashmitha v

Resize image with Node.js and AWS Lambda

Rashmitha v — Thu, 25 Jul 2024 17:57:27 +0000

Working
user upload file to s3 bucket. The bucket will notify the lambda that a new image was uploaded and it passes a key. The lambda will take this key and fetch the original image from the bucket then resize it and do any extra processing that it has to and then store it to a new bucket which will only store the resized images of the original image.

Architecture

Automate text Message(SMS) notification using SNS and AWS lambda

Rashmitha v — Sat, 13 Jul 2024 20:23:05 +0000

Introduction:
Automating SMS notifications using AWS Lambda and SNS (Simple Notification Service) is a powerful way to keep users informed about important events or updates in your application. AWS Lambda allows you to run code without provisioning or managing servers, while SNS enables you to send messages to a large number of recipients simultaneously.

working:
It is a source where the file is uploaded, this s3 bucket is configurated to trigger AWS lambda. lambda contains a python code which which perform event reading mechanism and publish the fully framed messages to SNS topic.To the SNS topic we will make phone and become a subscriber to the SNS topic and msg is publishes that text will receive about the event.

Architecture

AWS Amazon S3:

provide the name to the bucket.
create a bucket.

2.create a lambda function

provide the function name.
use the runtime as python 3.9
use the existing role

to change the setting click the configurations

change the memory size
change the timeout to reduce the cost
click save

click trigger
add trigger select 's3 bucket'
click event types and select "all object create events".
click add

paste the lambda code in the code source.

import boto3

topic_arn = ""
def send_sns(message, subject):
    try:
        client = boto3.client("sns")
        result = client.publish(TopicArn=topic_arn, Message=message, Subject=subject)
        if result['ResponseMetadata']['HTTPStatusCode'] == 200:
            print(result)
            print("Notification send successfully..!!!")
            return True
    except Exception as e:
        print("Error occured while publish notifications and error is : ", e)
        return True

def lambda_handler(event, context):
    print("event collected is {}".format(event))
    for record in event['Records'] :
        s3_bucket = record['s3']['bucket']['name']
        print("Bucket name is {}".format(s3_bucket))
        s3_key = record['s3']['object']['key']
        print("Bucket key name is {}".format(s3_key))
        from_path = "s3://{}/{}".format(s3_bucket, s3_key)
        print("from path {}".format(from_path))
        message = "The file is uploaded at S3 bucket path {}".format(from_path)
        subject = "Processes completion Notification"
        SNSResult = send_sns(message, subject)
        if SNSResult :
            print("Notification Sent..") 
            return SNSResult
        else:
            return False

deploy the code and test the code.

3.create the SNS topic

click the standard SNS topic.
provide a name to the SNS topic.
create a topic

arn code is generated this code is pasted in the lambda function before deploying and testing the code.

4.create subscribers:

provide the ARN
select the protocol(SMS)
SNS endpoint - phone number
click on text messages(SMS)

click add phone number in - 'sandbox destination phone number'
add phone no. , select the country and verify.

the phone is number is verified.

Subscribe Phone Numbers:

create subscription

choose topic.
select sms phone number appears after verification.

upload a dummy file to the trigger point i.e S3 and notification pops as a text message sent to phone.

Build a ChatGPT on AWS

Rashmitha v — Sat, 13 Jul 2024 14:02:03 +0000

Introduction
ChatGPT is based on OpenAI's GPT (Generative Pre-trained Transformer) architecture. It leverages deep learning to understand and generate human-like text based on the input it receives. Building a ChatGPT involves setting up a similar environment where your model can learn from data and interact with users in a conversational manner.

Service used:

API Gateway
lambda function
Bedrock
IAM Role

Create a bedrock:

It provides a foundation models:

base models
custom models
imported models the request access should be provided before using.

click on base model

no access to any model

Step 1:
To providing access click on 'enable all models'

Step 2:
uncheck the Anthropic models.

2.create an IAM role

click roles
choose lambda function as service.
add permissions (bedrockFullAccess)(cloudwatchlogFullAccess)
provide role name.

3.create a lambda function:

create a function name.
set the run time
choose existing role. function is created and click configuration to increase the timeout.

this is our request body the AI model

create a lambda code and paste it on the lambda_function.

4.create a API Gateway:
-create a API gateway to create a endpoints

click on restAPI
provide a name.

click regional and create a resource.

create a method.
choose method type "POST"
check the lambda proxy
choose the lambda function.
click create the method.

Deploy the APT

deploy the API to a new stage the API endpoint is create!

this API endpoint will call the lambda function to generate the response.

copy the lambda endpoint and paste it in the POSTMAN tool.
select the method as post.

Deploying a serverless web application on S3, API gateway, lambda, DynamoDB

Rashmitha v — Mon, 08 Jul 2024 21:11:26 +0000

Introduction:
Deploying a serverless web application using AWS services such as S3, API Gateway, Lambda, and DynamoDB is a streamlined and cost-effective approach for building scalable applications without managing traditional server infrastructure. This setup leverages cloud-native services that handle scaling, security, and availability automatically, allowing developers to focus on application logic rather than infrastructure maintenance.

Serverless Architecture

Components of the Serverless Architecture

Pre requisites:

AWS account
IAM role to lambda: Access dynamoDB

Creating AWS DynamoDB Table:

Fully managed NoSQL database service to store and retrieve data at scale.

Create a DynamoDB table by providing a name. (e.g., studentData).

Define Partition key which is used to retrieve or store the data(e.g., studentid)
sort key is define as secondary key.
create table

2.Creating a Lambda function:

Write Lambda functions to handle CRUD operations (GET, PUT, POST, DELETE) on DynamoDB data
create a function
define the function name(getstudent)
change the runtime to python 3.12
define role -use existing role.

write code
Lambda function (Python) for handling GET requests.

import json
import boto3

def lambda_handler(event, context):
    # Initialize a DynamoDB resource object for the specified region
    dynamodb = boto3.resource('dynamodb', region_name='us-east-2')

    # Select the DynamoDB table named 'studentData'
    table = dynamodb.Table('studentData')

    # Scan the table to retrieve all items
    response = table.scan()
    data = response['Items']

    # If there are more items to scan, continue scanning until all items are retrieved
    while 'LastEvaluatedKey' in response:
        response = table.scan(ExclusiveStartKey=response['LastEvaluatedKey'])
        data.extend(response['Items'])

    # Return the retrieved data
    return data

Deploy the above mentioned code

Test the code to invoke the lambda function i.e., lambda function will go to dynamo DB table and retrieve the data.

Lambda function (Python) for POSTING DATA

Create a function(E.g., insertStudentData)
select python 3.12 provide the roles.
create a function.

# Create a DynamoDB object using the AWS SDK
dynamodb = boto3.resource('dynamodb')
# Use the DynamoDB object to select our table
table = dynamodb.Table('studentData')

# Define the handler function that the Lambda service will use as an entry point
def lambda_handler(event, context):
    # Extract values from the event object we got from the Lambda service and store in variables
    student_id = event['studentid']
    name = event['name']
    student_class = event['class']
    age = event['age']

    # Write student data to the DynamoDB table and save the response in a variable
    response = table.put_item(
        Item={
            'studentid': student_id,
            'name': name,
            'class': student_class,
            'age': age
        }
    )

    # Return a properly formatted JSON object
    return {
        'statusCode': 200,
        'body': json.dumps('Student data saved successfully!')
    }

Deploy the code
test the code

student data will be stores in dynamo DB table

Create API gateway

-Create RESTful APIs to trigger Lambda functions to store or retrieve the datas in Dynamo DB table.

Create API endpoints (GET, POST, PUT, DELETE) in API Gateway that trigger your Lambda functions.
provide the API name student
-click API endpoint type - use (edge optimized) as it allow all the user.

Create methods - get and post methods

GET method

click on create method
method type - GET
integration type choose - lambda function
select lambda function - getStudent
method GET will be created.

POST method

method type - POST
select lambda function - insertStudentData
click create method

Deploy API
Deploy your API to a stage (e.g., prod) and note down the Invoke URL provided by API Gateway.

Paste the URL in API ENDPOINT code.

/ Add your API endpoint here
var API_ENDPOINT = "API_ENDPOINT_PASTE_HERE";

// AJAX POST request to save student data
document.getElementById("savestudent").onclick = function(){
    var inputData = {
        "studentid": $('#studentid').val(),
        "name": $('#name').val(),
        "class": $('#class').val(),
        "age": $('#age').val()
    };
    $.ajax({
        url: API_ENDPOINT,
        type: 'POST',
        data:  JSON.stringify(inputData),
        contentType: 'application/json; charset=utf-8',
        success: function (response) {
            document.getElementById("studentSaved").innerHTML = "Student Data Saved!";
        },
        error: function () {
            alert("Error saving student data.");
        }
    });
}

// AJAX GET request to retrieve all students
document.getElementById("getstudents").onclick = function(){  
    $.ajax({
        url: API_ENDPOINT,
        type: 'GET',
        contentType: 'application/json; charset=utf-8',
        success: function (response) {
            $('#studentTable tr').slice(1).remove();
            jQuery.each(response, function(i, data) {          
                $("#studentTable").append("<tr> \
                    <td>" + data['studentid'] + "</td> \
                    <td>" + data['name'] + "</td> \
                    <td>" + data['class'] + "</td> \
                    <td>" + data['age'] + "</td> \
                    </tr>");
            });
        },
        error: function () {
            alert("Error retrieving student data.");
        }
    });
}

If click on get-student data it will invoke the URL and lambda function will be triggered and it will retrieve data from dynamo DB table.

click resources
enable CORS -Select GET and POST and click save

Setting Up AWS S3

Create an S3 Bucket:

Go to the AWS Management Console and navigate to S3.
Click on "Create bucket" and follow the wizard to create a bucket (e.g., your-bucket-name).

Upload Static Web Content:

Upload your web application files (index.html,script.js) to the S3 bucket.

Select the uploaded files and make them public by setting the permissions to allow public read access.

Enable Static Website Hosting:

In the bucket properties, navigate to "Static website hosting".
Select "Use this bucket to host a website" and enter index.html as the Index document.

Our application is deployed in dynamo DB table!

Conclusion
Deploying a serverless web application using S3, API Gateway, Lambda, and DynamoDB offers scalability, cost-efficiency, and ease of maintenance. By leveraging these AWS services, developers can focus more on building application logic and less on managing infrastructure. This architecture is ideal for modern web applications that require flexibility, scalability, and seamless integration with backend services like DynamoDB

Creating a DynamoDB Table and Setting Up IAM Access Control

Rashmitha v — Mon, 08 Jul 2024 18:33:40 +0000

Introduction to DynamoDB Tables
Amazon DynamoDB is a fully managed NoSQL database service provided by AWS (Amazon Web Services). It offers high performance, seamless scalability, and low latency for applications needing consistent, single-digit millisecond response times. DynamoDB is particularly well-suited for applications requiring fast and predictable performance with seamless scalability.

Architecture:

_Step 1:Create a DynamoDB table for student details _

Navigate to the DynamoDB dashboard and click “Create table”, as show below.

When creating your DynamoDB table, you need to choose a name for the table and specify a Partition key.
The Partition key determines the partition in which the data is stored, while the Sort key helps in sorting the data within the partition based on its value.
Once you have named your table and assigned a partition key, navigate to the “Table settings” section.
simply click the “Create table” button in orange to initiate the table creation process

Step2 :Add items to DynamoDB table

Choose your recently created table from the list. In the left panel, click on “Explore items” and then select “Create item” to begin creating a new item within the table.

We are adding 6 student detail to the table.

Step 3: Launch EC2 with IAM role to scan DynamoDB table
Launching an EC2 instance with an IAM role that allows it to scan a DynamoDB table involves several steps, including creating an IAM role with appropriate permissions, launching the EC2 instance with that IAM role, and writing code on the EC2 instance to interact with DynamoDB.

In the next screen, give your role a name and click “Create role.”
step 4: Attach Policy

In the permissions tab, click "Attach policies directly".

Search for and attach the AmazonDynamoDBReadOnlyAccess policy (or create a custom policy with specific dynamodb:Scan permissions).

Step 5: Use the AWS CLI in the EC2 instance to scan the DynamoDB table
Navigate to the EC2 dashboard, then select your EC2 Instance.Then connect into your EC2 Instance by selection one of these ways:

I selected EC2 Instance Connect. We are now connected to our instance and ready to scan the table using the following command.

aws dynamodb scan --table-name <table_name> --region <region_name>

Benefits:

Scalability: DynamoDB scales automatically to handle any amount of traffic and storage.

Performance: Provides single-digit millisecond latency for read and write operations.

Security: IAM enables granular access control to DynamoDB resources, enhancing security posture.

Conclusion:
Setting up a DynamoDB table and configuring IAM access control ensures your application’s data storage is scalable, performant, and secure. By following best practices in defining table schemas, creating IAM policies, and integrating services, you establish a robust foundation for building cloud-native applications on AWS. This architecture supports modern application requirements with flexibility and resilience in data management.

Transforming Cloud Infrastructure with Terraform: Build, Change, Deploy

Rashmitha v — Sun, 30 Jun 2024 12:17:32 +0000

In today's cloud-centric landscape, managing infrastructure efficiently is key to scalability and reliability. Enter Terraform, an Infrastructure as Code (IaaC) tool that revolutionizes how we provision, manage, and evolve cloud resources across platforms like AWS, Azure, and Google Cloud. With Terraform, you define your infrastructure in declarative configuration files, ensuring consistency and repeatability. This process allows for swift deployment and seamless updates through its plan-apply cycle, enabling rapid iteration and ensuring infrastructure changes are predictable and reliable. Whether you're automating the setup of a new environment or orchestrating complex multi-cloud architectures, Terraform power lies in its ability to codify infrastructure as easily as software, unlocking agility and scalability while reducing operational overhead.

Building the infrastructure

1. Terraform Configuration

Each Terraform configuration must be in its own working directory. Create a directory for your configuration.

mkdir terraform-learning

Change into the directory

cd terraform-learning

Create a file to define your infrastructure.

code main.tf

Open main.tf in your text editor, give the configuration below, and save the file.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }

  required_version = ">= 1.2.0"
}

provider "aws" {
  region  = "us-west-2"
}

resource "aws_instance" "My_app_server" {
  ami           = "ami-830c94e3"
  instance_type = "t2.micro"

  tags = {
    Name = "ExampleInstance"
  }
}

2.Initialize the Terraform

terraform init

3. Create the infrastructure
Apply the configuration now with the terraform apply command.

terraform apply

Changing the infrastructure
1: Configuration of new AMI

resource "aws_instance" "My_app_server" {
-  ami           = "ami-830c94e3"
+  ami           = "ami-08d70e59c07c61a3a"
   instance_type = "t2.micro"
 }

2: Apply the changes

After changing the configuration, run terraform apply again to see how Terraform will apply this change to the existing resources.

terraform apply

Destroy the infrastructure
Once you no longer need infrastructure, you may want to destroy it to reduce your security exposure and costs.

terraform destroy

The terraform destroy command terminates resources managed by your Terraform project.
Defining the Input Variable

1: Set the instance name with variable

Create a new file called variables.tf with a block defining a new instance_name variable.

variable "instance_name" {
  description = "Value of the Name tag for the EC2 instance"
  type        = string
  default     = "ExampleInstance"
}

2: Update main.tf

In main.tf, update the aws_instance resource block to use the new variable. The instance_name variable block will default to its default value ("ExampleInstance") unless you declare a different value.

resource "aws_instance" "My_app_server" {
   ami           = "ami-08d70e59c07c61a3a"
   instance_type = "t2.micro"

   tags = {
-    Name = "ExampleInstance"
+    Name = var.instance_name
   }
 }

3: Apply Configuration_
Apply the configuration. Enter yes to confirm the cofiguration.

terraform apply

4: Passing the variable

Now apply the configuration again, this time overriding the default instance name by passing in a variable using the -var flag.

terraform apply -var "instance_name=SecondNameForInstance"

Query the Data
1: Output EC2 instance configuration

Create a file called outputs.tf in your learn-terraform-aws-instance directory.

code output.tf

2: Inspect output values

Apply the configuration and enter yes to confirm it.

terraform apply

3: Query Output value

Query the outputs with the terraform output command.

terraform output

In conclusion, Terraform stands as a transformative tool in the realm of cloud infrastructure management. By leveraging Infrastructure as Code principles, Terraform enables organizations to streamline the deployment and management of cloud resources across various providers. Its declarative configuration approach ensures consistency and reliability, facilitating rapid iteration and scalability.

Creating and Managing IAM users from Your EC2 instance

Rashmitha v — Sun, 30 Jun 2024 10:27:11 +0000

Introduction
Creating and managing IAM users from an EC2 instance involves a few steps to ensure proper security and access control. Here’s a general guide on how to accomplish this:

Step 1:
Create a EC2 instance.

step 2:
Connect to your EC2 instance using SSH.
open your terminal and run the following command
ssh -i path_to_your_key.pem ec2-user@your_ec2_public_dns

step 3:
create a new user
once connected to your EC2 instance, you can create a new user.
Use this command,replace new_username with the desired username:
sudo adduser new_username

Step 4:
set a password for the new user.
use the following code:
sudo passwd new_username

step 5:
verify the new user.
To verify that the user has been created successfully, use this command:
cat /etc/passwd

In conclusion, managing IAM users from your EC2 instance involves leveraging the AWS CLI and adhering to best practices for security and access control.