DEV Community: Mohana Priya

From Learning in Silence to Leading a Community

Mohana Priya — Tue, 20 Jan 2026 17:03:34 +0000

Hi, I’m Mohana Priya 👋

A Cloud Captain, DevOps Engineer… and once a student who didn’t know where she belonged.
There was a time when I sat quietly on the last bench, watching others speak with confidence, wondering if I would ever find my place. I didn’t have a clear dream, a strong voice, or a perfect plan for my future.

What I had was curiosity. And honestly, a lot of self-doubt.

I never imagined that one decision—to join Cloud Clubs, would slowly change the way I saw myself.

Before vs After Cloud Clubs: A Journey I’ll Always Cherish and Carry

Before: Learning in Silence
Before Cloud Clubs, I was not confident. I rarely spoke, never asked questions, and mastered the art of sitting on the last bench without being noticed.

I didn’t know what cloud computing was. All I knew was that I wanted to learn—but I was waiting for the “start here” sign to appear.

Cloud Clubs was where I heard about AWS Cloud Computing for the first time. I remember opening the AWS Console and feeling a strange mix of excitement and fear. Everything looked powerful… and expensive. I was scared to click anything, worried I’d make a mistake that couldn’t be undone.

I made plenty of beginner mistakes, some I laugh about now:

Creating resources and forgetting to delete them
Mixing up regions and availability zones
Attending sessions and still going home to Google the basics

But behind those funny moments was something deeper—I was trying. Even when I felt lost, I kept showing up.

The Change I Felt:
What changed everything wasn’t just learning cloud services. It was the people.

I joined the AWS Cloud Club at my university simply as a member—quiet, observant, unsure of where I fit. I attended sessions, listened closely, and learned at my own pace. But as I kept showing up, something began to shift.

Watching my former Cloud Captains lead events, guide students, and create opportunities made me feel something I hadn’t felt before—belonging. For the first time, I didn’t feel invisible.

Gradually, I became part of the core team. I started supporting my former Cloud Captain, helping with event coordination, assisting peers with certifications and projects, and being there wherever help was needed. Not because I knew everything, but because I wanted to grow alongside the community.

With every small responsibility I was trusted with, my confidence grew.
Helping others helped me believe in myself.

Slowly, without even realizing it,
I found my voice.

After: Standing Where I Once Watched
When I became a Cloud Captain, it felt surreal. I wasn’t just learning anymore, I was leading.

I still remember my first event as a Cloud Captain, volunteering with the UG WomenInTech team at AWSheTech Day. Standing on stage, delivering the welcome note, my heart was pounding. But in that moment, I realized something powerful—I had become the person I once looked up to.

From that first step to organizing Student Community Day with nearly 500+ participants and 28 speakers across India, Cloud Clubs transformed me, not overnight, but step by step.

What This Journey Gave Me:
Cloud Clubs gave me more than technical skills:

Courage to speak even when my voice shook
Confidence to take responsibility
Leadership rooted in empathy
The belief that I belonged here

The certification support helped me prove my knowledge, secure two internships, and today, I work as a DevOps Engineer, a role I once thought was far beyond my reach.

To the student reading this—

If you often listen more than you speak,
If curiosity lives inside you but fear holds you back,
If you sometimes feel like everyone else is moving ahead while you’re still figuring things out…

You’re not alone.
I’ve stood exactly where you are.

⏳ The Cloud Clubs application deadline is Jan 20 2026. Just a few hours left.

Don’t wait for confidence to come first.
Sometimes, growth begins with just showing up.

Apply for the cloud clubs program now:

pulse.aws

For more details visit:

builder.aws.com/cloud-clubs

Take the step. Trust the journey. Your “after” is waiting.

Building a Continuous Delivery Pipeline for Web Applications on AWS

Mohana Priya — Sat, 07 Dec 2024 11:35:21 +0000

Imagine making changes to your application and deploying them live with just a few steps. Continuous Delivery Pipeline makes this possible! In this blog, we’ll walk through setting up an automated pipeline using AWS services for a simple memory-matching game built with HTML, CSS, and JavaScript.

https://github.com/mohanapriyas1808/codepipeline-s3-game

What is a Continuous Delivery Pipeline?

Before we jump into the exciting process of building one, let’s first understand what a Continuous Delivery Pipeline is.

A Continuous Delivery (CD) Pipeline is a series of automated steps that streamline the journey of your application code from a developer's workstation to a live, production-ready environment. It ensures that:

Code Changes are Tested: Each update is automatically verified for functionality.
Changes are Reviewed: A manual or automated review step ensures quality control.
Deployments are Seamless: Updates go live without interrupting the user experience. Think of it as an assembly line for your software. Just like cars in a factory pass through various stages assembly, painting, quality checks, and packaging your code moves through a pipeline: source control → build → test → review → deploy.

Why to use a Continuous Delivery Pipeline?

Automation: Eliminates manual deployment tasks, saving time and effort.
Faster Deployment: Speeds up the release of new features and fixes.
Consistency: Ensures every deployment follows a reliable, tested process.

Pre-requisites

An AWS account
A GitHub account
Git installed on your computer

Application Architecture

How the Pipeline Works ?

Here’s a quick overview of what we’re building:

Source Stage: Fetches your code from GitHub.
Build Stage: Uses CodeBuild to test and package your game.
Approval Stage: Adds a manual review step to check your changes.
Deploy Stage: Automatically uploads your game to an S3 bucket with static web hosting.

Simple, right? Let’s break it down step by step.

Step 1: Set Up Your GitHub Repository

Create a repository on GitHub and push your game application source code.
Make sure your code is clean, well-structured, and ready to be deployed.

Step 2: Configure S3 for Hosting

Go to the S3 dashboard in AWS and create a new bucket with Block all public access disabled.
Enable Static Web Hosting in the bucket properties.
Update the bucket policy to make your application publicly accessible.

Bucket Policy
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::Bucket-Name/*"
            ]
        }
    ]
}

Step 3: Create a Build Project in CodeBuild

Open CodeBuild and create a new project.
Connect to GitHub using OAuth and select your source code repository.
Select Amazon Linux 2 from the Operating system dropdown menu.
Select Standard from the Runtime(s) dropdown menu.
Select aws/codebuild/amazonlinux2-x86_64-standard:5.0 from the Image dropdown menu.
Confirm that Linux is selected for Environment type.
Confirm that New service role is selected.
Select Insert build commands.
Choose Switch to editor.
Replace the Buildspec in the editor with the code below:

version: 0.2
phases:
  install:
    commands:
      - echo "No dependencies to install for static HTML application"
  build:
    commands:
      - echo "No build step needed for static HTML, CSS, and JavaScript files"
artifacts:
  files:
    - '**/*.html'  
    - '**/*.css'  
    - '**/*.js'    
    - 'images/**'  
  discard-paths: no

11.Click the Create Project button and hit Start Build to test it!

Step 4: Set Up the Continuous Delivery Pipeline in AWS CodePipeline

Open CodePipeline and create a new pipeline.
Confirm that New service role is selected.
Select GitHub version 1 from the Source provider dropdown menu.
Connect to GitHub and select your source code repository.
Select main from the branch dropdown menu
Confirm that GitHub webhooks is selected.
Choose Next and select the CodeBuild project you just created.
Choose Next and select your S3 bucket which you have created for deployment with static web hosting enabled.
Review the pipeline and click the create pipeline button.

Access you application using the object's URL in the s3 bucket.

Step 5: Add a Review Stage

Choose the Edit button near the top of the page.
Choose the Add stage button between the Build and Deploy stages.
In the created stage, choose the Add action group button.
From the Action provider dropdown, select Manual approval.
Hit the Done button and the Save button in the top of the page to save the changes.
You will now see your pipeline with four stages: Source, Build, Review, and Deploy.

Step 6: Test the Pipeline

Commit a change to your source code in the github repository (in this case i have changed the name MEME Matching Game to Image Matching Game.
Watch the pipeline automatically start.
Approve the changes in the review stage.
Your updated game will be live now on the S3 bucket!

Once the Deploy Stage is complete refresh your application page to see the changes.

Conclusion

By combining AWS services like CodePipeline, CodeBuild, and S3, you can create a robust continuous delivery pipeline for your applications. This setup ensures a seamless deployment process, allowing you to focus on improving your application rather than worrying about deployments.

Ready to build your own pipeline? Start experimenting with AWS today!

🚀 Automate Your Resume Hosting with CI/CD and AWS EC2 🌐

Mohana Priya — Sun, 14 Jul 2024 14:25:17 +0000

Introduction:

CI/CD is a method used in modern software development to automate the process of integrating code changes, testing them, and deploying applications. This approach ensures that code changes are continuously tested and deployed, leading to faster development cycles and more reliable applications.

In this project, we utilize CI/CD to host a personal resume website on an EC2 instance using GitHub Actions. By automating the deployment process, any updates made to the resume repository are automatically reflected on the live website. This not only reduces manual effort but also ensures that the resume is always current and available to potential employers or collaborators.By integrating GitHub Actions with AWS, you can achieve continuous deployment, ensuring that any changes made to your resume are automatically reflected online.

This article helps you understand how you can automatically deploy your code to AWS EC2 from GitHub.

Step-1: Launch an EC2 instance with the Ubuntu server. Modify the security group inbound rules to allow SSH (port 22), HTTP (port 80), and HTTPS (port 443).

Step-2: Create a public repository on GitHub for example Host-Resume-on-ec2-githubactions.
Add an index.html file containing the code for your resume website.
Add a CSS file for styling your resume.

Step-3: Add secrets to the repository for secure information storage.

EC2_SSH_KEY: Your key pair file for SSH access.
HOST_DNS: The public DNS of your EC2 instance.
USERNAME: The username for SSH (e.g., ubuntu).
TARGET_DIR: The target directory on the EC2 instance (e.g., home).

Step-4: Create a .github/workflows directory in your repository.
Add a YAML file (e.g., github-actions-ec2.yml) with the following code to automate deployment:

Add the following code so that your actions only run when you push to main branch.

# Trigger deployment only on push to main branch
on:
  push:
    branches:
      - main

jobs:
  deploy:
    name: Deploy to EC2 on master branch push
    runs-on: ubuntu-latest

    steps:
      - name: Checkout the files
        uses: actions/checkout@v2

      - name: Deploy to Server 1
        uses: easingthemes/ssh-deploy@main
        env:
          SSH_PRIVATE_KEY: ${{ secrets.EC2_SSH_KEY }}
          REMOTE_HOST: ${{ secrets.HOST_DNS }}
          REMOTE_USER: ${{ secrets.USERNAME }}
          TARGET: ${{ secrets.TARGET_DIR }}

      - name: Executing remote ssh commands using ssh key
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST_DNS }}
          username: ${{ secrets.USERNAME }}
          key: ${{ secrets.EC2_SSH_KEY }}
          script: |
            sudo apt-get -y update
            sudo apt-get install -y apache2
            sudo systemctl start apache2
            sudo systemctl enable apache2
            cd home
            sudo mv * /var/www/html

Once done with this your workflow will be created and using the public IP address if the EC2 instance you can view the resume.

If any update was done in your main branch you can able to view by refreshing the page.

Conclusion:

Hosting a resume on an EC2 instance using GitHub Actions combines the power of cloud infrastructure with the automation of CI/CD workflows. This method ensures that your resume is always up-to-date and accessible, demonstrating technical skills and modern development practices. This approach can be extended to various applications, making it a versatile solution for web hosting needs.

Automating EC2 Instance Management with AWS Lambda and EventBridge Using Terraform

Mohana Priya — Mon, 08 Jul 2024 15:47:16 +0000

Introduction:

EC2 instances are virtual servers for running applications on the AWS infrastructure. It is crucial for providing scalable computing capacity, allowing users to deploy and manage applications efficiently in the cloud. EC2 instances are widely used for hosting websites, running databases, and handling various computing workloads.

Managing EC2 instances manually can be a daunting task, especially when dealing with multiple instances and varying usage patterns. Automating this process not only saves time but also ensures that your resources are used efficiently, leading to significant cost savings. By leveraging AWS Lambda, EventBridge, and Terraform, you can create an automated solution that starts and stops your EC2 instances based on a schedule, ensuring optimal resource utilization and cost efficiency.

In this guide, we'll take you through the entire process of setting up this automation, from creating the EC2 instances to configuring the Lambda functions and EventBridge rules using Terraform. Let's dive in and unlock the potential of automated cloud resource management!

Architecture:

EC2: An EC2 instance is a virtual server which is used for running applications on the AWS infrastructure.

Lambda: AWS Lambda is a serverless compute service that lets you run code without provisioning or managing servers. It automatically scales applications by running code in response to events. Lambda is widely used for event-driven applications, real-time file processing, and backend services.

EventBridge: Amazon EventBridge is a serverless event bus service that makes it easy to connect applications using data from your own apps, SaaS apps, and AWS services. It simplifies event-driven architecture by routing events between services and allowing you to build scalable, event-driven workflows for various use cases such as application integration, automation, and observability.

IAM Role: An IAM (Identity and Access Management) role in AWS defines permissions for entities like AWS services or users, ensuring secure access to AWS resources without needing long-term credentials. Roles are used to delegate permissions across AWS services and are integral for managing security and access control within cloud environments.

Pre-requisites:
Before we dive into the steps, let's ensure you have the following prerequisites in place:

AWS Account: If you don't have one, sign up for an AWS account.
Terraform Installed: Download and install Terraform from the official website.
AWS CLI Installed: Install the AWS CLI by following the instructions here.
AWS Credentials Configured: Configure your AWS CLI with your credentials by running aws configure.

Step-By-Step Procedure:

We'll walk you through the entire process of setting up this automation using Terraform. The steps include configuring the AWS provider, creating the EC2 instances, setting up IAM roles and policies, defining the Lambda functions, and creating the EventBridge rules.

Step-1: Create a main.tf file. This file contains the configuration for creating three instances, IAM role for the lambda function to access the EC2 instance, lambda functions for starting the EC2 instances and stopping the EC2 instances, EventBridge rules for triggering the startec2instance lambda function and stopec2instance lambda function.



provider "aws" {
  region = "ap-south-1"
}

resource "aws_instance" "ec2" {
  count                  = var.instance_count
  ami                    = "ami-02a2af70a66af6dfb"  
  instance_type          = "t2.micro"  # Update with your desired instance type
  vpc_security_group_ids = [var.security_group_id]
  subnet_id              = var.subnet_id
  key_name               = var.key
  tags = merge(var.default_ec2_tags,
    {
      Name = "${var.name}-${count.index + 1}"
    }
  )
}

resource "aws_iam_role" "lambda_role" {
  name = "lambda_role"

  # Terraform's "jsonencode" function converts a
  # Terraform expression result to valid JSON syntax.
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Sid    = ""
        Principal = {
          Service = "lambda.amazonaws.com"
        }
      },
    ]
  })

  tags = {
    tag-key = "tag-value"
  }
}

resource "aws_iam_policy" "lambda_policy_start_stop_instance" {
  name        = "lambda_policy_start_stop_instance"
  path        = "/"
  description = "My test policy"


  # Terraform expression result to valid JSON syntax.
  policy = jsonencode({
    Version = "2012-10-17"
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:Start*",
                "ec2:Stop*",
                "ec2:Describe*"
            ],
            "Resource": "*"
        }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "test-attach" {
  role       = aws_iam_role.lambda_role.name
  policy_arn = aws_iam_policy.lambda_policy_start_stop_instance.arn
}


resource "aws_lambda_function" "stop_ec2_instance" {
  # If the file is not in the current working directory you will need to include a
  # path.module in the filename.
  filename      = "stopec2instance.zip"
  function_name = "stop_ec2_instance"
  role          =  aws_iam_role.lambda_role.arn
  handler       = "stopec2instance.lambda_handler"
  source_code_hash = filebase64sha256("stopec2instance.zip")

  runtime = "python3.11"
}

resource "aws_lambda_function" "start_ec2_instance" {
  # If the file is not in the current working directory you will need to include a
  # path.module in the filename.
  filename      = "startec2instance.zip"
  function_name = "startec2instance"
  role          =  aws_iam_role.lambda_role.arn
  handler       = "startec2instance.lambda_handler"
  source_code_hash = filebase64sha256("startec2instance.zip")

  runtime = "python3.11"
}


resource "aws_cloudwatch_event_rule" "stop_ec2_schedule" {
    name                = "stop_ec2_schedule"
    description         = "Schedule to trigger Lambda to stop EC2 instances every 2 minutes"
    schedule_expression = "rate(2 minutes)"
  }


resource "aws_cloudwatch_event_target" "stop_ec2_target" {
  rule      = aws_cloudwatch_event_rule.stop_ec2_schedule.name
  target_id = "lambda"
  arn       = aws_lambda_function.stop_ec2_instance.arn
}

resource "aws_lambda_permission" "allow_cloudwatch_stop" {
  statement_id  = "AllowExecutionFromCloudWatch"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.stop_ec2_instance.function_name
  principal     = "events.amazonaws.com"
  source_arn    = aws_cloudwatch_event_rule.stop_ec2_schedule.arn
}

resource "aws_cloudwatch_event_rule" "start_ec2_schedule" {
    name                = "start_ec2_schedule"
    description         = "Schedule to trigger Lambda to start EC2 instances every 1 minute"
    schedule_expression = "rate(1 minute)"
  }

resource "aws_cloudwatch_event_target" "start_ec2_target" {
  rule      = aws_cloudwatch_event_rule.start_ec2_schedule.name
  target_id = "lambda"
  arn       = aws_lambda_function.start_ec2_instance.arn
}

resource "aws_lambda_permission" "allow_cloudwatch_start" {
  statement_id  = "AllowExecutionFromCloudWatch"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.start_ec2_instance.function_name
  principal     = "events.amazonaws.com"
  source_arn    = aws_cloudwatch_event_rule.start_ec2_schedule.arn
}

Step-2: Create variables.tf file

variable "instance_count" {
  description = "Number of EC2 instances to create"
  default     = 3
}

variable "security_group_id" {
  description = "ID of the security group for EC2 instances"

}

variable "subnet_id" {
  description = "ID of the subnet for EC2 instances"

}

variable "key" {
  description = "Name of the SSH key pair for EC2 instances"

}

variable "name" {
  description = "Name prefix for EC2 instances"

}

variable "default_ec2_tags" {
  type        = map(string)
  description = "(optional) default tags for EC2 instances"
  default = {
    managed_by   = "terraform"
    Environment  = "Dev"
  }
}

Step-3: Create terraform.tfvars file which contains configuration such as number of instance, security group id, subnet id, key pair name, name of the instance.

instance_count     = 3
security_group_id  = "sg-0944b5d5471b421fb"
subnet_id          = "subnet-0582feff6651618d4"
key                = "mynewkeypair"
name               = "EC2-Test-Instance"

Step-4: Create two python files stopec2instance, startec2instance this files contain the code for the lambda function. Make sure the python files are zipped and they lie in the same directory.

#stopec2instance
import boto3

def is_dev(instance):
    is_dev = False
    if 'Tags' in instance:
        for tag in instance['Tags']:
            if tag['Key'] == 'Environment' and tag['Value'] == 'Dev':
                is_dev = True
                break
    return is_dev

def is_running(instance):
    return instance['State']['Name'] == 'running'

def lambda_handler(event, context):
    ec2 = boto3.client('ec2', region_name='ap-south-1')

    try:
        response = ec2.describe_instances()
        reservations = response['Reservations']

        for reservation in reservations:
            for instance in reservation['Instances']:
                if is_dev(instance) and is_running(instance):
                    instance_id = instance['InstanceId']
                    ec2.stop_instances(InstanceIds=[instance_id])
                    print(f'Stopping instance: {instance_id}')

    except Exception as e:
        print(f'Error stopping instances: {str(e)}')

    return {
        'statusCode': 200,
        'body': 'Function executed successfully'
    }

#startec2instance
import boto3

def is_dev(instance):
    is_dev = False
    if 'Tags' in instance:
        for tag in instance['Tags']:
            if tag['Key'] == 'Environment' and tag['Value'] == 'Dev':
                is_dev = True
                break
    return is_dev

def is_stopped(instance):
    return instance['State']['Name'] == 'stopped'

def lambda_handler(event, context):
    ec2 = boto3.client('ec2', region_name='ap-south-1')

    try:
        response = ec2.describe_instances()
        reservations = response['Reservations']

        for reservation in reservations:
            for instance in reservation['Instances']:
                if is_dev(instance) and is_stopped(instance):
                    instance_id = instance['InstanceId']
                    ec2.start_instances(InstanceIds=[instance_id])
                    print(f'Starting instance: {instance_id}')

    except Exception as e:
        print(f'Error starting instances: {str(e)}')

    return {
        'statusCode': 200,
        'body': 'Function executed successfully'
    }

terraform init: — To initialize the backend that means terraform will check in this step what is the provider used here and correspondingly download all the dependencies of that provider (AWS in our case) if everything is fine the output will show somewhat like this :

terraform plan: In this step terraform will show you how many resources it will create like this :

terraform apply: In this step it wil actually create the resources based on the previous step

Once all the resources are created the output will be like this:

EC2 instance

Lambda Function

EventBridge Rules

Whenever the lambda function is triggered by EventBridge rules the output will be like this

If you want to delete the resources you have to give terraform destroy command.

Conclusion:
By automating the start and stop of EC2 instances using Lambda, EventBridge, and Terraform, we've created an efficient and cost-effective solution for managing our cloud resources. This setup can be easily adapted to suit different schedules and requirements.

Happy automating!

Streamlining Data Conversion: XML to JSON with AWS Lambda and S3

Mohana Priya — Mon, 01 Jul 2024 15:21:50 +0000

Introduction:
In today's data-driven world, managing and transforming data formats efficiently is crucial for seamless integration and processing. XML (eXtensible Markup Language) and JSON (JavaScript Object Notation) are two widely used data formats, each with its own set of advantages. However, there are scenarios where converting data from XML to JSON becomes necessary to leverage JSON's simplicity and compatibility with modern web applications and APIs.

AWS (Amazon Web Services) provides a robust and scalable solution for such data transformation tasks using S3 buckets and Lambda functions. In this blog, we will walk you through the process of setting up an automated workflow that converts XML files stored in an S3 bucket to JSON format and uploads them to another S3 bucket using AWS Lambda. By the end of this tutorial, you'll have a clear understanding of how to harness the power of AWS to simplify your data processing pipelines.

Step-1: Setting Up S3 Buckets
First, create two S3 buckets: one for storing the input XML files and another for storing the converted JSON files. For this tutorial, we'll refer to them as input-bucket and output-bucket.

Step-2: Creating the Lambda Function
Navigate to the AWS Lambda console and create a new Lambda function using the Python 3.9 runtime.

Step-3: Configuring the Lambda Function
Permissions: Ensure your Lambda function has the necessary permissions to read from the input-bucket and write to the output-bucket. Attach an IAM role with S3FullAccess policies.

Code: Use the following code to handle the XML to JSON conversion and upload the converted file to the output bucket:

import json
import xml.etree.ElementTree as ET
import boto3

s3 = boto3.client('s3')

def parse_element(element):
    parsed_data = {}
    if element.attrib:
        parsed_data.update(('@' + k, v) for k, v in element.attrib.items())
    if element.text and element.text.strip():
        parsed_data['#text'] = element.text.strip()
    children = list(element)
    if children:
        child_data = {}
        for child in children:
            child_dict = parse_element(child)
            child_tag = child.tag
            if child_tag not in child_data:
                child_data[child_tag] = []
            child_data[child_tag].append(child_dict)
        for k, v in child_data.items():
            if len(v) == 1:
                parsed_data[k] = v[0]
            else:
                parsed_data[k] = v
    return parsed_data

def xml_to_json(xml_content):
    root = ET.fromstring(xml_content)
    return json.dumps(parse_element(root), indent=4)

def lambda_handler(event, context):
    source_bucket = 'input-bucket'  # Replace with your source bucket name
    destination_bucket = 'output-bucket'  # Replace with your destination bucket name

    try:
        records = event['Records']
    except KeyError:
        return {
            'statusCode': 400,
            'body': json.dumps('Event does not contain Records key.')
        }

    for record in records:
        try:
            key = record['s3']['object']['key']
        except KeyError:
            return {
                'statusCode': 400,
                'body': json.dumps('Record does not contain S3 object key.')
            }

        if key.endswith('.xml'):
            xml_obj = s3.get_object(Bucket=source_bucket, Key=key)
            xml_content = xml_obj['Body'].read().decode('utf-8')

            json_content = xml_to_json(xml_content)
            json_key = key.replace('.xml', '.json')
            s3.put_object(Bucket=destination_bucket, Key=json_key, Body=json_content)

            return {
                'statusCode': 200,
                'body': json.dumps('XML to JSON conversion and upload successful!')
            }
        else:
            return {
                'statusCode': 400,
                'body': json.dumps('The file is not an XML file.')
            }

Step-4: Setting Up S3 Trigger

Configure an S3 trigger for the input-bucket to invoke the Lambda function whenever a new XML file is uploaded. This ensures that the function is automatically triggered and processes the file as soon as it is added to the bucket.

Step-5: Testing the Workflow

Upload a sample XML file to the input-bucket and verify that the Lambda function is triggered. Check the output-bucket for the converted JSON file. For example, you can use the following XML content for testing:

<?xml version="1.0" encoding="UTF-8"?>
<note>
    <to>Tove</to>
    <from>Jani</from>
    <heading>Reminder</heading>
    <body>Don't forget me this weekend!</body>
</note>

Output:
The output of this lambda function will be:

Conclusion:
By following the steps outlined in this blog, you have successfully set up an automated system for converting XML files to JSON using AWS Lambda and S3. This approach leverages the scalability and reliability of AWS services to streamline your data processing tasks, making your workflows more efficient and easier to manage.

Whether you are handling large datasets or integrating with systems that require JSON format, this solution provides a robust and scalable way to manage your data transformations. Start leveraging AWS Lambda and S3 today to simplify your data processing pipelines and enhance your application's performance.

Automating Email Notifications for S3 Object Uploads using SNS

Mohana Priya — Sun, 30 Jun 2024 14:59:13 +0000

Introduction:

In today's cloud-centric world, automation is key to managing and scaling infrastructure efficiently. Amazon Web Services (AWS) offers a robust suite of services that allow developers to build complex systems with relative ease. One such powerful combination is Amazon Simple Storage Service (S3) and Amazon Simple Notification Service (SNS). Together, they can automate notifications for various events, such as when a new object is uploaded to an S3 bucket. This blog post will guide you through the process of setting up an S3 bucket, creating an SNS topic, subscribing to the topic via email, and configuring the system to send notifications when objects are uploaded to the S3 bucket.

Step-1: Create an S3 Bucket
First, we need an S3 bucket where objects will be stored. Follow these steps to create an S3 bucket:

1.Navigate to the S3 console: Open the AWS Management Console and navigate to the S3 service.
2.Create a new bucket:Click on "Create bucket" and provide a unique name for your bucket. Choose the appropriate region and configure other settings as per your requirements. For this example, we’ll stick with the default settings.
3.Create the bucket: Click on "Create bucket" to finalize the creation.

Step-2: Create an SNS Topic
Next, we’ll create an SNS topic to which notifications will be sent.

1. Navigate to the SNS console: Open the AWS Management Console and navigate to the SNS service.
2. Create a topic: Click on "Create topic", select "Standard" for the topic type, and provide a name for your topic. Click on "Create topic" to finalize the creation.

Step-3: Subscribe to the SNS Topic via Email
To receive notifications, we need to subscribe to the SNS topic using an email address.

1. Create a subscription:In the SNS console, select your topic and click on "Create subscription".
2. Set protocol and endpoint: Choose "Email" as the protocol and enter your email address in the endpoint field.
3. Confirm the subscription: AWS will send a confirmation email to the provided address. Check your email and click on the confirmation link to complete the subscription.

Step-4: Update the SNS Topic Access Policy
To allow S3 to publish messages to the SNS topic, we need to modify the topic's access policy.

1. Edit the policy: In the SNS console, select your topic and click on "Edit" under the Access Policy section.
2. Add the policy: Add the following policy to allow S3 to publish notifications:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "s3.amazonaws.com"
      },
      "Action": "SNS:Publish",
      "Resource": "arn:aws:sns:your-region:your-account-id:your-topic-name"
    }
  ]
}

Step-5: Configure S3 to Send Notifications to SNS
Finally, configure the S3 bucket to send notifications to the SNS topic when an object is uploaded.

1. Navigate to the S3 bucket: In the S3 console, select your bucket and click on the "Properties" tab.
2. Add a notification: Under the "Event notifications" section, click on "Create event notification".
3. Configure the event: Provide a name for the notification, select the "All object create events" event type, and choose SNS topic as the destination. Select your SNS topic from the dropdown and save the configuration.

Step-6: Upload the object
At last upload the object in the s3 bucket that has been created.

SNS will send notification to the subscribed email once the object is uploaded in the S3 bucket.

Conclusion:
By following the steps outlined in this blog post, you have successfully set up an automated notification system that sends an email whenever a new object is uploaded to your S3 bucket. This integration between S3 and SNS not only demonstrates the power of AWS services but also showcases how they can be used to build robust and automated workflows. Whether for operational monitoring, security alerts, or just keeping track of changes in your storage, this setup is a valuable tool in any cloud infrastructure arsenal. Happy automating!

Creating and Managing IAM Users from Your EC2 Instance

Mohana Priya — Sat, 29 Jun 2024 15:48:58 +0000

Introduction:
Managing user access on your EC2 instance is a fundamental task for maintaining security and efficiency in your AWS environment. In this guide, we'll walk you through creating a new user from the EC2 instance, setting up SSH access, and verifying the new user. Let's get started!

Step-1: Create a EC2 instance
Create a ec2 instance in the console.

Step-2: Connect to your EC2 instance
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

Replace path_to_your_key.pem with the path to your private key file and your_ec2_public_dns with the public DNS of your EC2 instance.

Step-3: Create a new user
Once connected to your EC2 instance, you can create a new user. Use the following command, replacing new_username with the desired username:

sudo adduser new_username

This command creates a new user and sets up a home directory for them.

Step-4: Set a password for the new user
Next, set a password for the new user. Use this command to set password for the new user.

sudo passwd new_username

Step-5: Verify the New User
To verify that the new user has been created successfully, use this command

cat /etc/passwd

You should see an entry similar to this:

new_username:x:1001:1001::/home/new_username:/bin/bash

This confirms that the new user has been added to the system.

Conclusion:
Creating and managing users on your EC2 instance is a straightforward process that enhances your system's security and accessibility. By following these steps, you can efficiently add new users, set up SSH access, and verify their presence on your system.

Regularly review and manage user accounts to maintain a secure and organized environment. Happy managing!

Transforming Cloud Infrastructure with Terraform: Build, Change, Deploy

Mohana Priya — Thu, 27 Jun 2024 18:18:30 +0000

Intoduction:
In today's fast-paced tech world, infrastructure as code (IaC) has become essential for managing and automating your cloud resources. Recently, I had the opportunity to dive into Terraform, an open-source IaC tool that allows you to define and provision your infrastructure using a simple, declarative programming language. In this blog, I'll walk you through my journey of building, changing, and deploying infrastructure, as well as querying data outputs using Terraform.

Pre-requisites:

Before we dive into the steps, let's ensure you have the following prerequisites in place:

AWS Account: If you don't have one, sign up for an AWS account.
Terraform Installed: Download and install Terraform from the official website.
AWS CLI Installed: Install the AWS CLI by following the instructions here.
AWS Credentials Configured: Configure your AWS CLI with your credentials by running aws configure.

Building the infrastructure

Step-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"
  }
}

Step-2: Initialize the Terraform

Initializing a configuration directory download and installs the providers defined in the configuration, which in this case is the aws provider.

terraform init

Step-3: Create the infrastructure

Apply the configuration now with the terraform apply command.

terraform apply

Enter Yes to apply the cofiguration.
You have now created infrastructure using Terraform! Visit the EC2 console and find your new EC2 instance.

Changing the infrastructure

Step-1: Configuration of new ami

Now update the ami of your instance. Change the aws_instance.My_app_server resource under the provider block in main.tf by replacing the current AMI ID with a new one.

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

Step-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

As included before terraform destroys the existing instance first and the create the new instance in place of it.

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

Step-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"
}

Step-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
   }
 }

Step-3: Apply Configuration

Apply the configuration. Enter yes to confirm the cofiguration.

terraform apply

Step-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"

Terraform will update the instance's Name tag with the new name.

Query the Data

Step-1: Output EC2 instance configuration

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

code output.tf

Step-2: Inspect output values

Apply the configuration and enter yes to confirm it.

terraform apply

Step-3: Query Output value

Query the outputs with the terraform output command.

terraform output

Conclusion:

Working with Terraform has been an enlightening experience. Its simplicity and power make managing infrastructure a breeze. Whether you're setting up a static website or managing complex cloud environments, Terraform's declarative approach and extensive provider support have got you covered.
Happy Coding!

Hosting a Static Website on Amazon S3 with Terraform: A Step-by-Step Guide

Mohana Priya — Thu, 27 Jun 2024 04:30:02 +0000

Introduction
In the world of web development, static websites offer a straightforward and efficient way to present content without the complexities of server-side processing. Amazon S3 provides a robust platform for hosting these static websites, ensuring high availability and scalability. To further streamline the deployment process, Terraform, an Infrastructure as Code (IaC) tool, can be used to automate the creation and management of your AWS resources.

This guide will walk you through the process of hosting a static website on Amazon S3 using Terraform, leveraging a modular file structure for clarity and ease of management. By the end of this tutorial, you'll have a fully functional static website hosted on Amazon S3, managed entirely through Terraform.

Prerequisites
Before we dive into the steps, let's ensure you have the following prerequisites in place:

AWS Account: If you don't have one, sign up for an AWS account.
Terraform Installed: Download and install Terraform from the official website.
AWS CLI Installed: Install the AWS CLI by following the instructions here.
AWS Credentials Configured: Configure your AWS CLI with your credentials by running aws configure.

Step-1: Create the Directory Structure
First, let's create a directory for our Terraform project and navigate into it.

mkdir my-static-website
cd my-static-website

Step-2: Define your Terraform Configuration

Create a file named terraform.tf and define your provider configuration. This configuration sets up the Terraform to use the AWS provider, specifying your AWS profile and region

# Terraform
terraform {
  required_version = "1.8.5"
  required_providers {
    aws = {
        source = "hashicorp/aws"
        version = "5.40.0"
    }
  }
}

#Provider
provider "aws" {
  profile = "default"
  region = "us-east-1"
}

Step-3: Create the S3 bucket
Create a file named bucket.tf to define your S3 bucket and its configuration. This defines a S3 bucket and uploads an index.html file to it.

# Create S3 Bucket
resource "aws_s3_bucket" "terraform-demo-1808" {
  bucket = "terraform-demo-1808"
}

# Upload file to S3
resource "aws_s3_object" "terraform_index" {
  bucket = aws_s3_bucket.terraform-demo-1808.id
  key = "index.html"
  source = "index.html"
  content_type = "text/html"
  etag = filemd5("index.html")
}

# S3 Web hosting
resource "aws_s3_bucket_website_configuration" "terraform_hosting" {
  bucket = aws_s3_bucket.terraform-demo-1808.id

  index_document {
    suffix = "index.html"
  }
}

Step-4: Set up the bucket policies
Create a file named policy.tf to define your S3 bucket policies to allow public access. This block temporarily disables S3’s default Block Public Access settings for this specific bucket.

# S3 public access
resource "aws_s3_bucket_public_access_block" "terraform-demo" {
    bucket = aws_s3_bucket.terraform-demo-1808.id
  block_public_acls = false
  block_public_policy = false
}

# S3 public Read policy
resource "aws_s3_bucket_policy" "open_access" {
  bucket = aws_s3_bucket.terraform-demo-1808.id

  policy = jsonencode({
    Version = "2012-10-17"
    Id      = "Public_access"
    Statement = [
      {
        Sid = "IPAllow"
        Effect = "Allow"
        Principal = "*"
        Action = ["s3:GetObject"]
        Resource = "${aws_s3_bucket.terraform-demo-1808.arn}/*"
      },
    ]
  })
  depends_on = [ aws_s3_bucket_public_access_block.terraform-demo ]
}

Step-5: Configure the Output variable
Create a file named output.tf for your website's URL.

# Website URL
output "website_url" {
  value = "http://${aws_s3_bucket.terraform-demo-1808.bucket}.s3-website.${aws_s3_bucket.terraform-demo-1808.region}.amazonaws.com"
}

Step-6: Initialize your terraform
It essentially prepares Terraform’s working directory for managing infrastructure. It downloads and installs any required provider plugins based on your configuration like hashicorp/aws provider.

terraform init

Step-7: Terraform Validate
It performs a static analysis of your Terraform configuration files and validates the overall syntax of your Terraform code, ensuring it adheres to the Terraform language rules.

terraform validate

Step-8: Terraform Plan
It is used for understanding and reviewing the intended changes to your infrastructure before actually applying them.

terraform plan

Step-9: Terraform Apply
The Terraform apply command in Terraform is the one that actually executes the actions outlined in the plan generated by the Terraform plan. It’s the final step in making the desired infrastructure changes a reality.

terraform apply

Step-10: Access your website
After the apply process completes terraform will output your website's URL. Visit the URL to see your static website live.

Conclusion:
Congratulations! You've successfully hosted a static website on Amazon S3 using Terraform. This approach not only makes deployment straightforward but also ensures your infrastructure is version-controlled and easily reproducible.

By following this guide, you can quickly deploy static websites for various purposes, such as personal blogs, portfolios, or documentation sites. Explore the power of Infrastructure as Code with Terraform and take your web hosting to the next level!