DEV Community: Kaviya Kathirvelu

Building a Serverless CRUD API with AWS: A Comprehensive Guide

Kaviya Kathirvelu — Tue, 09 Jul 2024 06:39:14 +0000

Introduction

In the era of cloud computing, serverless architectures have become a game-changer, allowing developers to build and deploy applications without worrying about the underlying infrastructure. AWS offers a powerful suite of services that make it easy to create serverless applications. In this blog, we'll walk you through building a serverless CRUD (Create, Read, Update, Delete) API using AWS Lambda, API Gateway, IAM, and DynamoDB.

Why Choose Serverless?

Serverless computing offers several advantages:

Scalability:
Automatically scales with the demand.
Cost-Efficiency:
Pay only for what you use.
Reduced Operational Overhead:
Focus on code rather than infrastructure.
High Availability:
Built-in redundancy and fault tolerance.

Components of Our Serverless CRUD API

API Gateway:
Acts as the entry point for your API.
AWS Lambda:
Executes your business logic.
IAM:
Manages access and permissions.
DynamoDB:
A NoSQL database for storing your data.
Postman software:
A software that is used to write code and send requests to the API Gateway

Step-by-Step Guide

Set Up DynamoDB
Create a DynamoDB table named product-inventory with productid as the partition key.
Create Lambda Functions
Create Lambda functions for each CRUD operation. Here's an example of a Lambda function for handling all CRUD operations:
Deploy Lambda Functions
Deploy your Lambda functions using the AWS Management Console or AWS CLI.
Here is a sample code:

const AWS = require('aws-sdk');
AWS.config.update( {
  region: 'us-east-1'
});
const dynamodb = new AWS.DynamoDB.DocumentClient();
const dynamodbTableName = 'product-inventory';
const healthPath = '/health';
const productPath = '/product';
const productsPath = '/products';

exports.handler = async function(event) {
  console.log('Request event: ', event);
  let response;
  switch(true) {
    case event.httpMethod === 'GET' && event.path === healthPath:
      response = buildResponse(200);
      break;
    case event.httpMethod === 'GET' && event.path === productPath:
      response = await getProduct(event.queryStringParameters.productid);
      break;
    case event.httpMethod === 'GET' && event.path === productsPath:
      response = await getProducts();
      break;
    case event.httpMethod === 'POST' && event.path === productPath:
      response = await saveProduct(JSON.parse(event.body));
      break;
    case event.httpMethod === 'PATCH' && event.path === productPath:
      const requestBody = JSON.parse(event.body);
      response = await modifyProduct(requestBody.productid, requestBody.updateKey, requestBody.updateValue);
      break;
    case event.httpMethod === 'DELETE' && event.path === productPath:
      response = await deleteProduct(JSON.parse(event.body).productid);
      break;
    default:
      response = buildResponse(404, '404 Not Found');
  }
  return response;
}

async function getProduct(productid) {
  const params = {
    TableName: dynamodbTableName,
    Key: {
      'productid': productid
    }
  }
  return await dynamodb.get(params).promise().then((response) => {
    return buildResponse(200, response.Item);
  }, (error) => {
    console.error('Do your custom error handling here. I am just gonna log it: ', error);
  });
}

async function getProducts() {
  const params = {
    TableName: dynamodbTableName
  }
  const allProducts = await scanDynamoRecords(params, []);
  const body = {
    products: allProducts
  }
  return buildResponse(200, body);
}

async function scanDynamoRecords(scanParams, itemArray) {
  try {
    const dynamoData = await dynamodb.scan(scanParams).promise();
    itemArray = itemArray.concat(dynamoData.Items);
    if (dynamoData.LastEvaluatedKey) {
      scanParams.ExclusiveStartkey = dynamoData.LastEvaluatedKey;
      return await scanDynamoRecords(scanParams, itemArray);
    }
    return itemArray;
  } catch(error) {
    console.error('Do your custom error handling here. I am just gonna log it: ', error);
  }
}

async function saveProduct(requestBody) {
  const params = {
    TableName: dynamodbTableName,
    Item: requestBody
  }
  return await dynamodb.put(params).promise().then(() => {
    const body = {
      Operation: 'SAVE',
      Message: 'SUCCESS',
      Item: requestBody
    }
    return buildResponse(200, body);
  }, (error) => {
    console.error('Do your custom error handling here. I am just gonna log it: ', error);
  })
}

async function modifyProduct(productid, updateKey, updateValue) {
  const params = {
    TableName: dynamodbTableName,
    Key: {
      'productid': productid
    },
    UpdateExpression: `set ${updateKey} = :value`,
    ExpressionAttributeValues: {
      ':value': updateValue
    },
    ReturnValues: 'UPDATED_NEW'
  }
  return await dynamodb.update(params).promise().then((response) => {
    const body = {
      Operation: 'UPDATE',
      Message: 'SUCCESS',
      UpdatedAttributes: response
    }
    return buildResponse(200, body);
  }, (error) => {
    console.error('Do your custom error handling here. I am just gonna log it: ', error);
  })
}

async function deleteProduct(productid) {
  const params = {
    TableName: dynamodbTableName,
    Key: {
      'productid': productid
    },
    ReturnValues: 'ALL_OLD'
  }
  return await dynamodb.delete(params).promise().then((response) => {
    const body = {
      Operation: 'DELETE',
      Message: 'SUCCESS',
      Item: response
    }
    return buildResponse(200, body);
  }, (error) => {
    console.error('Do your custom error handling here. I am just gonna log it: ', error);
  })
}

function buildResponse(statusCode, body) {
  return {
    statusCode: statusCode,
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(body)
  }
}

Set Up API Gateway Create an API:

Choose REST API.
Set up methods (GET, POST, PATCH, DELETE) for your resources (/health, /product, /products).
Integrate each method with the respective Lambda function.
Enable CORS and enable proxy for the resources
Configure CORS settings for each method.
Deploy the API:
Create a new deployment stage (e.g., dev, prod).

Configure IAM Roles
Ensure your Lambda functions have the necessary permissions to interact with DynamoDB. Create an IAM role with policies that allow dynamodb to perform actions on your table.
Testing the API
Use tools like Postman or CURL to test your API endpoints. Ensure each CRUD operation works as expected:

GET /health: Check API health.
GET /product?productid=10001: Retrieve a specific product.
GET /products: Retrieve all products.
POST /product: Create a new product.
PATCH /product: Update an existing product.
DELETE /product: Delete a product.

Benefits of Using Serverless CRUD API

Scalability: Automatically scales with demand.
Cost-Efficiency: Pay only for what you use.
Reduced Operational Overhead: No need to manage servers.
High Availability: Built-in redundancy and fault tolerance.
Security: Fine-grained access control with IAM.

Conclusion

Building a serverless CRUD API using AWS Lambda, API Gateway, IAM, and DynamoDB is an excellent choice for scalable, cost-effective, and secure backend solutions. With the steps outlined in this blog, you can quickly set up your own serverless API and start leveraging the power of AWS for your applications.

Happy coding!

Creating an EC2 Instance and Connecting via SSH with IAM User

Kaviya Kathirvelu — Fri, 28 Jun 2024 01:45:41 +0000

Introduction

Creating and managing cloud infrastructure can be streamlined with AWS and Terraform. This blog post will guide you through the process of creating an EC2 instance and an IAM user using the AWS Management Console, and then connecting to the instance via SSH.

Prerequisites

Before we begin, ensure you have the following:

An AWS account.
Basic understanding of AWS services and SSH.

Step 1: Creating an EC2 Instance in AWS Management Console

Log in to the AWS Management Console.
Navigate to the EC2 Dashboard: Click on "Services" in the top menu and select "EC2" under the "Compute" section.
Launch an Instance: Click the "Launch Instance" button.
Select an Amazon Machine Image (AMI) of your choice.
Choose an instance type (e.g., t2.micro for free tier eligibility).
Configure the instance details as needed.
Add storage as required.
Add tags to help identify your instance.
Configure the security group to allow SSH access (port 22).
Review and launch the instance.
Download the Key Pair: When prompted, create a new key pair or use an existing one. Download the key pair file (e.g., my-key-pair.pem) and save it securely.

Step 2:** Creating an IAM User in AWS Management Console**

Navigate to the IAM Dashboard: Click on "Services" in the top menu and select "IAM" under the "Security, Identity, & Compliance" section.
Create a New User: Click the "Add user" button. Enter a username (e.g., example-user). Select the "Programmatic access" checkbox to provide access via the AWS CLI, SDKs, etc.
Set Permissions: Attach existing policies directly or create a new policy to grant necessary permissions.
Review and Create User: Review the settings and click "Create user." Download the access key ID and secret access key, as you will not be able to view them again.

Step 3: Connecting to the EC2 Instance via SSH

Locate the Public IP Address: In the EC2 Dashboard, select your instance. Note the public IPv4 address from the instance details.
Set Permissions on the Key Pair File: Open your terminal and navigate to the directory containing the key pair file.
Run the following command to set the correct permissions:

chmod 400 my-key-pair.pem

Connect to the Instance:

Use the following SSH command to connect to your instance:

ssh -i "my-key-pair.pem" ec2-user@<your_instance_public_ip>

Replace with the public IP address of your instance.

Conclusion

You've successfully created an EC2 instance and an IAM user using the AWS Management Console and connected to the instance via SSH. This process highlights the basic steps to get started with AWS EC2 and IAM, laying the groundwork for more complex configurations and automations.

Building a Static Website with Terraform: Step-by-Step Guide

Kaviya Kathirvelu — Tue, 25 Jun 2024 14:57:17 +0000

Creating and hosting a static website has never been easier with the power of Infrastructure as Code (IaC) and cloud services. In this guide, we'll walk you through setting up a static website using Terraform to manage AWS resources. You'll learn how to automate the creation of an S3 bucket, configure it for static website hosting, deploy your website files, and some additional considerations.

Prerequisites

Before we start, ensure you have the following:
• An AWS account.
• AWS CLI installed and configured with appropriate permissions.
• Terraform installed.

Step 1: Initialize Your Project

Create a new directory for your Terraform project and navigate to 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:

terraform {
  required_version = ">= 1.8.5"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.40.0"
    }
  }
}

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

This configuration sets up Terraform to use the AWS provider, specifying your AWS profile and region.

Step 3: Create the S3 Bucket

Create a file named bucket.tf to define your S3 bucket and its configuration:

resource "aws_s3_bucket" "terraform_demo_43234" {
  bucket = "terraform-demo-43234-unique-id" # Ensure this bucket name is unique
}

resource "aws_s3_object" "terraform_index" {
  bucket       = aws_s3_bucket.terraform_demo_43234.id
  key          = "index.html"
  source       = "index.html"
  content_type = "text/html"
  etag         = filemd5("index.html")
}

resource "aws_s3_bucket_website_configuration" "terraform_hosting" {
  bucket = aws_s3_bucket.terraform_demo_43234.id

  index_document {
    suffix = "index.html"
  }
}

This defines an S3 bucket and uploads an index.html file to it, configuring the bucket for static website hosting.

Step 4: Set Bucket Policies

Create a file named policy.tf to define your S3 bucket policies for public access:

resource "aws_s3_bucket_public_access_block" "terraform_demo" {
  bucket                  = aws_s3_bucket.terraform_demo_43234.id
  block_public_acls       = false
  block_public_policy     = false
}

resource "aws_s3_bucket_policy" "open_access" {
  bucket = aws_s3_bucket.terraform_demo_43234.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_43234.arn}/*"
      },
    ]
  })

  depends_on = [aws_s3_bucket_public_access_block.terraform_demo]
}

This ensures your bucket's objects are publicly accessible.

Step 5: Output the Website URL

Create a file named output.tf to output your website's URL:

output "website_url" {
  value = "http://${aws_s3_bucket.terraform_demo_43234.bucket}.s3-website.${aws_s3_bucket.terraform_demo_43234.region}.amazonaws.com"
}

This outputs the URL of your hosted static website after deployment.

Step 6: Deploy Your Static Website

1. Initialize Terraform:

terraform init

This command prepares your working directory for other Terraform commands.

2. Apply the Configuration:

terraform apply

Review the changes and confirm with yes.

3. Access Your Website:

After the apply process completes, Terraform will output your website's URL. Visit this URL to see your static website live.

Additional Considerations

• Custom Domain: To use a custom domain for your static website, you can set up Route 53 for DNS management and CloudFront for CDN and SSL/TLS termination.

• Versioning and Backup: Enable versioning on your S3 bucket to maintain backups of your files. This helps in case of accidental deletion or modification.

• Security: Review and implement appropriate security measures, such as bucket policies and IAM roles, to restrict access and protect your resources.

• Monitoring and Logging: Set up S3 access logging and CloudWatch alarms to monitor and manage your static website's performance and availability.

Conclusion

Congratulations! You've successfully deployed a static website using Terraform on AWS. By leveraging Infrastructure as Code, you can manage your resources efficiently and ensure consistency across deployments. This approach not only saves time but also enhances scalability and maintainability for your projects.

Feel free to explore more Terraform resources and customize your setup further. Happy coding!