DEV Community: Harshana vivekanandhan

Architecting a Secure and Scalable Network with AWS VPCs and Subnets

Harshana vivekanandhan — Mon, 08 Jul 2024 17:22:18 +0000

Building a secure and scalable network in the cloud is critical for any organization that leverages cloud services. AWS Virtual Private Cloud (VPC) and its associated subnets provide the foundational infrastructure to achieve these goals. This blog post will guide you through the process of architecting a secure and scalable network using AWS VPCs and subnets.

Project Prerequisites

An AWS account that is free-tier eligible because we don’t want to spend money on this project.
Basic knowledge of VPCs, subnets, Network ACLs, routing and security groups.

My Architecture Diagram

Creating a custom VPC and Subnets

I will launch all the resources I use in this project in the North Virginia region. If you want to follow along to the last detail, make sure you are also launching your resources in the North Virginia region.

Now let’s create our VPC. Creating a VPC has been made easier as you can create your VPC and subnets, and define route tables and other VPC resources in one go.
Here change the IPv4 CIDR block and the zones and subnets to 1 gateways and endpoints to None

Configuring Security Groups

To locate the security group console, we have to search and navigate to the EC2 management console window. Once in the EC2 dashboard navigate to the security groups tab and create a security group as shown in the image below.{https://whatismyipaddress.com/ip/110.224.90.87} to find the IP address
Here Allow SSH from local computer to bastion host launched in public subnet.

Setting up a Bastion Host

The next step in the project is to launch a bastion host in the public subnet via which we are going to connect to an EC2 instance launched in the private subnet. So let’s get that done. Within your management console, navigate to the EC2 window. To make sure we don’t accrue any cost, we are going to use an AMI that is free-tier eligible.
While launching the EC2 instance, be sure to select the security group we created earlier as its security group. After having filled in all the details, clicking on the Launch instance button launches our bastion host EC2 instance.

Launch Private EC2 Instance

We need another EC2 instance in our private subnet which we are going to access it using SSH via the bastion host. This instance is going to use the same key pair and security group as the bastion host in the public subnet.

SSH to Bastion Host

The time to start testing our work has come. We are going to access our bastion host from our computer. So open a terminal window and run the following commands.



chmod 400 /path/to/private/key.pem

This command will secure the key pair file that was downloaded when we created our key pair. After that, the next command to be run is:



ssh -i path/to/key.pem ec2-user@bastion-public-ip

Make sure you edit the command as needed before running it. With that, we will be connected to our bastion host and we can now connect to the private instance via SSH from the bastion host. To do that, run the following command:



ssh ec2-user@private-instance-private-ip

That’s all that there is to it. Now close the connection to your EC2 instances by running the edit command



**exit**

command.

Creating a Scalable Serverless Chat Application on AWS

Harshana vivekanandhan — Mon, 08 Jul 2024 09:59:53 +0000

Today I had used a AWS serverless services like AWS Lambda and API Gateway to build a chat application in the AWS cloud that can effortlessly scale to meet high demand.

Prerequisites

-An AWS account with an IAM user that has administrative permissions.

A basic understanding of a high-level programming language such as Python is recommended but not required.
Basic understanding of databases and APIs.
Grit and persistence.

My Architecture Diagram

Create A Lambda Function

Open the Lambda console: From the AWS Management Console, open the AWS Lambda console by searching for "Lambda" in the services search bar.

Create three function:
Function:1
Click on the "Create function" button.
Choose "Author from scratch".
Configure the following settings:
Function name: Send Message
Runtime: Python 3.x (choose the latest available version)
Role: Choose "Create a new role with basic Lambda permissions"
Click "Create function" to create your Lambda function.

Function:2
Click on the "Create function" button.
Choose "Author from scratch".
Configure the following settings:
Function name: Connect
Runtime: Python 3.x (choose the latest available version)
Role: Choose "Create a new role with basic Lambda permissions"
Click "Create function" to create your Lambda function.

Function:3
Click on the "Create function" button.
Choose "Author from scratch".
Configure the following settings:
Function name: Disconnect
Runtime: Python 3.x (choose the latest available version)
Role: Choose "Create a new role with basic Lambda permissions"
Click "Create function" to create your Lambda function.

Create an API

creating an API using API Gateway which is a managed service that makes it fun and easy for developers to create, publish, maintain, monitor, and secure APIs to back-end systems running on EC2, AWS Lambda or any publicly addressable web service

In the API Gateway console, click on the Build button under WebSocket APIs as shown below
You can create a route selection expression like $request.body.action to route messages based on their "action" attribute as we have done in our case. Then, you'd define route actions for different "action" values, such as:

Route Key: sendMessage
Integration: Lambda function to handle the messages
This way, incoming messages will be routed to the appropriate backend Lambda functions based on their “action” attribute. Now let’s go to add routes.

Add Code to the Lambda Function

Edit the function code:

Scroll down to the "Function code" section.
In the inline code editor, you will see a file named lambda_function.py. This file contains the handler code for your Lambda function.
Write your code: Replace the default code with the following code:
for Send Message

python
Copy code

import json
import urllib3
import boto3
client = boto3.client('apigatewaymanagementapi', endpoint_url="xxxxxxxxxx.com/production")

def lambda_handler(event, context):
    print(event)
    #Extract connectionId from incoming event
    connectionId = event["requestContext"]["connectionId"]
    #Do something interesting... 
    responseMessage = "I am fine"
    #Form response and post back to connectionId
    response = client.post_to_connection(ConnectionId=connectionId, Data=json.dumps(responseMessage).encode('utf-8'))
    return { "statusCode": 200  }

for connect and disconnect

import json

def lambda_handler(event, context):
    print(event)
    print("****")
    print(context)
    return { "statusCode": 200 }

Testing our Send Message Route

To make sure our Lambda function is working as integration for our API and a client can send messages, we are going to test our send message route. So go back to []{https://piehost.com/websocket-tester} with the WebSocket connection still open and try sending a message in the format:

{
  "action": "sendMessage",
  "message": "Hello, how are you?"
}

Serverless Application using AWS Lambda ,Api Gateway,AWS Amplify

Harshana vivekanandhan — Fri, 05 Jul 2024 16:20:11 +0000

Creating a serverless application using AWS Lambda, API Gateway, and AWS Amplify involves a series of steps to set up and integrate these services. Here's a high-level overview of the process:

1. Set Up AWS Lambda Function

AWS Lambda is a compute service that lets you run code without provisioning or managing servers.

Create a Lambda Function:
- Go to the AWS Management Console.
- Navigate to AWS Lambda.
- Click on "Create function."
- Choose a blueprint or start from scratch.
- Configure the function (name, runtime, permissions, etc.).
- Write your function code or upload a zip file.
Configure the Lambda Function:
- Set up environment variables if needed.
- Configure the function's execution role to allow necessary permissions.

2. Create an API with Amazon API Gateway

Amazon API Gateway allows you to create and publish RESTful APIs.

Create an API:
- Go to the AWS Management Console.
- Navigate to API Gateway.
- Click on "Create API" and choose REST API.
Define Resources and Methods:
- Create resources (e.g., /items).
- Add methods (e.g., GET, POST) to the resources.
- Integrate these methods with your Lambda functions by specifying the Lambda ARN.
Deploy the API:
- Create a new stage (e.g., dev).
- Deploy the API to this stage.
- Note the invoke URL provided by API Gateway for later use.

3. Set Up AWS Amplify

AWS Amplify is a set of tools and services to help front-end web and mobile developers build scalable full-stack applications.

Initialize a New Amplify Project:
- Install Amplify CLI: npm install -g @aws-amplify/cli.
- Configure the CLI: amplify configure (follow the prompts to set up your AWS profile).
- Initialize your Amplify project: amplify init.
Add API to Your Amplify Project:
- Add an API: amplify add api.
- Choose REST when prompted and provide the necessary details (e.g., path, Lambda integration).
- Push the changes to the cloud: amplify push.

4. Build and Deploy Your Frontend with Amplify

Create Your Frontend Application:
- You can use frameworks like React, Angular, or Vue.js.
- Amplify supports hosting for static websites.
Host Your Application with Amplify:
- Go to the AWS Amplify Console.
- Connect your repository (e.g., GitHub, GitLab).
- Configure build settings and deploy.

5. Testing and Iteration

Test your application end-to-end.
Make necessary adjustments to the Lambda functions, API Gateway configurations, or frontend code.
Utilize Amplify's CI/CD capabilities for automatic deployment on code changes.

Example: Simple Serverless To-Do Application

Here’s a basic example of a serverless To-Do application using AWS Lambda, API Gateway, and AWS Amplify:

Lambda Function: A simple Lambda function to handle CRUD operations on to-do items.
API Gateway: Configure a REST API with paths like /todos and methods like GET, POST, DELETE.
Amplify Frontend: A React application integrated with the API.

Hosting a Static Website Using S3 in AWS with Terraform

Harshana vivekanandhan — Thu, 27 Jun 2024 18:06:28 +0000

Introduction
Hi there! I've been investigating Terraforms and AWS's capabilities as part of my internship. I recently worked on Hosting a Static Website Using S3 in AWS with Terraform
Hosting a static website on Amazon S3 is a cost-effective and scalable solution that can be easily managed using Terraform. This tutorial will guide you through the steps to set up and deploy a static website using S3 with Terraform.

Prerequisites

Before you begin, ensure you have the following:

AWS Account: If you don’t have one, create it here.
Terraform Installed: Download and install Terraform from the official site.
AWS CLI Configured: Install and configure the AWS CLI. Follow the instructions here.

Step-by-Step Guide

1. Set Up Your Terraform Project

Create a Directory: Start by creating a directory for your Terraform project.
Create the main.tf File: This file will contain the Terraform configuration for your S3 static website.

2. Initialize Terraform

Run the following command to initialize your Terraform project:

3. Plan the Deployment

Run the terraform plan command to see what Terraform will do:

4. Apply the Configuration

Apply the configuration to create the S3 bucket and upload the website files:
Terraform will prompt for confirmation. Type yes to proceed.

5. Verify the Deployment

Once the apply command completes, Terraform will output the website URL. You can access your static website using this URL.

Conclusion

Using Terraform to host a static website on Amazon S3 simplifies the deployment and management process. With infrastructure as code, you can version, reproduce, and maintain your static websites more efficiently. This guide provides a foundational setup, which you can expand upon by adding more resources and configurations as needed.By leveraging Terraform and AWS S3, you can quickly deploy scalable and reliable static websites, making your web hosting process smoother and more efficient.

Creating, Modifying, and Destroying an EC2 Instance in AWS with Terraform

Harshana vivekanandhan — Thu, 27 Jun 2024 16:58:01 +0000

Introduction

Hi there! I've been investigating Terraforms and AWS's capabilities as part of my internship. I recently worked on using Terraform to create, modify, and terminate an EC2 instance. This blog will go over the procedures I took, the difficulties I ran across, and the fixes I discovered.

Prerequisites

Before we dive in, ensure you have the following:

✔️AWS Account: If you don't have one, you can create it here.
✔️Terraform Installed: Download and install Terraform from the official site.
✔️AWS CLI Configured: Install and configure the AWS CLI. Follow the instructions here.

Setting Up Your Terraform Project

✨Create a Directory: Start by creating a directory for your Terraform project.
✨Initialize Terraform: Create a new file named main.tf where we'll define our Terraform configuration.
✨Initialize Terraform: Initialize the Terraform working directory.

Creating an EC2 Instance

1.Plan the Execution: Run terraform plan to see what Terraform will do.
2.Apply the Configuration: Apply the configuration to create the EC2 instance.
3.Terraform will prompt for confirmation. Type yes to proceed. After a few moments, your EC2 instance will be created.

Modifying the EC2 Instance

Suppose you want to change the instance type. Edit the main.tf file.
1.Plan the Changes: Run terraform plan to see the changes.
2.Apply the Changes: Apply the configuration to update the EC2 instance.

Destroying the EC2 Instance

When you no longer need the EC2 instance, you can destroy it using Terraform.
1.Destroy the Resource: Run the terraform destroy command. Terraform will prompt for confirmation. Type yes to proceed. Terraform will then destroy the EC2 instance and clean up the resources.

Conclusion

Using Terraform to manage AWS resources simplifies infrastructure management by allowing you to define your infrastructure as code. In this blog post, we covered the basics of creating, modifying, and destroying an EC2 instance with Terraform. This process can be extended to manage more complex infrastructures by leveraging Terraforms extensive provider and resource support. By adopting Terraform, you can ensure your infrastructure is versioned, reproducible, and maintainable, paving the way for more efficient and reliable cloud resource management.