DEV Community: Chinthaka Dinadasa 🇱🇰

Deploying Spring Boot Applications With AWS ECS Fargate (Free Course)

Chinthaka Dinadasa 🇱🇰 — Tue, 18 Jul 2023 14:07:52 +0000

AWS Elastic Container Service (ECS) Fargate is a fully-managed container orchestration service that allows developers to deploy and manage containers without managing underlying EC2 instances.

Deploying Spring Boot applications with ECS Fargate can be an excellent choice for organizations that want to reduce infrastructure management overhead and increase the scalability and reliability of their applications.

When combined, Spring Boot and AWS ECS Fargate provide a powerful solution for deploying and managing Java applications in a containerized environment.

By utilizing Spring Boot’s ease of development and AWS ECS Fargate’s simplicity of deployment, developers can build scalable and highly available applications that leverage the benefits of containerization.

Welcome to the start of our article series, where we will explore the process of setting up a Spring Boot REST API on AWS ECS Fargate from scratch as a totally free course.

In this comprehensive guide, we will take you through each step involved in deploying your Spring Boot application as a containerized REST API using the power of AWS ECS Fargate.

What Are We Going To Build

In this series, we are going to explore how we can set up the following architecture which consists of all the necessary AWS Cloud components to achieve our goal of deploying the spring boot application on AWS ECS fargate.

Here’s a glimpse of what you can expect to learn throughout the series:

Introduction to Spring Boot and AWS ECS Fargate: Get acquainted with the key concepts of Spring Boot and AWS ECS Fargate, understanding how they complement each other in building scalable and efficient applications.
Setting up AWS Infrastructure: Learn how to create the necessary infrastructure components on AWS, including VPC (Virtual Private Cloud), subnets, security groups, and IAM roles.
Containerizing the Spring Boot Application: Explore the process of packaging your Spring Boot application as a Docker container, including defining dependencies, configuring the Dockerfile, and building the image.
Creating an AWS ECS Cluster: Dive into the world of ECS (Elastic Container Service) and create an ECS cluster to manage your containerized applications.
Configuring ECS Task Definitions: Understand the role of ECS task definitions in defining the properties and requirements of your containers. We’ll guide you through creating a task definition for your Spring Boot REST API.
Launching ECS Services: Discover how to launch ECS services that run your containers, ensuring high availability, scalability, and seamless deployment of your Spring Boot REST API.
Setting up a custom domain with SSL using Route 53: Discover how we should place SSL certificates from the Amazon Certificate manager and point those to the load balancer to enable HTTPS public access to the API.
Setting up Amazon Cloudwatch for log management inside the ECS services with best practices in deployments.

Article Series

Happy coding.

How to Build AWS VPC Using Terraform - Step By Step

Chinthaka Dinadasa 🇱🇰 — Tue, 25 Apr 2023 17:46:51 +0000

As more organizations migrate their infrastructure to the cloud, the need for resilient and secure Virtual Private Cloud (VPC) networks becomes more important. AWS offers a powerful VPC service that allows users to create their own virtual network in the cloud.

However, setting up and managing a VPC can be difficult and time-consuming. That's where Terraform comes in as an open-source infrastructure as a code tool that can help automate creating and managing AWS resources.

In this article, we'll explore how to use Terraform to create a VPC on AWS, including the various components that make up a VPC and the steps required to implement them. By the end of this article, you'll know exactly how to use Terraform to build your own secure and scalable VPC network on AWS.

The architecture we are going to setup

This setup includes the following components within the VPC that we will set up using Terraform.

AWC VPC – Base Virtual Private Cloud that creates in the AWS.
Subnets – Includes private and public subnets within 2 availability zones. (Here I’ve used 2 availability zones, but feel free to add more AZs per your requirement.)
Internet Gateway – will allow instances under the public subnet to access the public internet and users to access things on the public subnet via the internet.
NAT Gateway – will allow instances under private subnet to access public internet when there is any requirement like download patches, os updates, etc. But a NAT gateway allows only one-way communication that will not open a private subnet to the public internet.
Security Groups – Security groups will be used in allowing who can access what inside this architecture
Route tables – used to build the routing for IGW and NAT gateway.

Prerequisites

To follow this tutorial you will need:

The Terraform CLI (1.2.0+) installed.
The AWS CLI is installed.
AWS account and associated credentials that allow you to create resources.

Let’s focus on building the VPC now.

Initiate Terraform Configuration

First, we need to initiate the terraform folder where we can keep all the configurations related to our terraform setup.

$ mkdir terraform-configuration
$ cd terraform-configuration

create main.tf and copy the following content where we define providers to the terraform.

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

  required_version = ">= 1.2.0"
}

Then run the following command to initiate terraform in this directory.

$ terraform init

Basic Terraform Commands

We have the ability to validate the config before applying it on a real AWS environment using Terraform Validate.

$ terraform validate

Additionally, we can plan the configuration before applying it on a real AWS environment using Terraform plan, Which shows what we are going to publish and the changes that going to apply on the AWS.

$ terraform plan

Also we can format the terraform configuration document using following command,

$ terraform fmt

Define input variables for Terraform

Terraform configurations can include variables to make our configuration more dynamic and flexible rather than hard code those whenever needed.

let’s create the vars.tf where we can manage all the variables to the configuration that we are going to build.

variable "aws_region" {
  default = "us-east-1"
}

variable "environment" {
  default = "javatodev"
}

variable "vpc_cidr" {
  default     = "10.0.0.0/16"
  description = "CIDR block of the vpc"
}

variable "public_subnets_cidr" {
  type        = list(any)
  default     = ["10.0.0.0/20", "10.0.128.0/20"]
  description = "CIDR block for Public Subnet"
}

variable "private_subnets_cidr" {
  type        = list(any)
  default     = ["10.0.16.0/20", "10.0.144.0/20"]
  description = "CIDR block for Private Subnet"
}

Define provider with an AWS region

Here we have to use the AWS provider with setting AWS region where we should publish this configuration and build the architecture.

Additionally, here we are referring to variables we have defined in the earlier stage as well.

provider "aws" {
  region = var.aws_region
}

Local Values

A local value assigns a name to an expression, so you can use the name multiple times within a module instead of repeating the expression.

Local values are like a function’s temporary local variables in programming languages.

Now we need to set the following availability zones in this setup.

us-east-1a
us-east-1b

we set availability zones in this setup as a local value as follows, and refer to those when needed within other instructions.

locals {
  availability_zones = ["${var.aws_region}a", "${var.aws_region}b"]
}

Define VPC and other components

VPC – Virtual Private Network

Now we can start defining the VPC and related components inside the necessary architecture.

Let’s begin with instructions on VPC creation.

# VPC
resource "aws_vpc" "vpc" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.environment}-vpc"
    Environment = var.environment
  }
}

Now we have a resource that we can create on AWS with Terraform, Let’s apply this VPC and check with the AWS VPC dashboard on that specific region.

$ terraform apply

Private and Public Subnets Inside VPC

Let’s configure the private and public subnets that we are going to place inside this VPC.

# Public subnet
resource "aws_subnet" "public_subnet" {
  vpc_id                  = aws_vpc.vpc.id
  count                   = length(var.public_subnets_cidr)
  cidr_block              = element(var.public_subnets_cidr, count.index)
  availability_zone       = element(local.availability_zones, count.index)
  map_public_ip_on_launch = true

  tags = {
    Name        = "${var.environment}-${element(local.availability_zones, count.index)}-public-subnet"
    Environment = "${var.environment}"
  }
}

# Private Subnet
resource "aws_subnet" "private_subnet" {
  vpc_id                  = aws_vpc.vpc.id
  count                   = length(var.private_subnets_cidr)
  cidr_block              = element(var.private_subnets_cidr, count.index)
  availability_zone       = element(local.availability_zones, count.index)
  map_public_ip_on_launch = false

  tags = {
    Name        = "${var.environment}-${element(local.availability_zones, count.index)}-private-subnet"
    Environment = "${var.environment}"
  }
}

Internet Gateway and NAT Gateway

Internet gateway allows connecting the VPC to the Internet and to other AWS services through public internet.

NAT gateway that instances in a private subnet can connect to services outside your VPC but external services cannot initiate a connection with those instances.

#Internet gateway
resource "aws_internet_gateway" "ig" {
  vpc_id = aws_vpc.vpc.id
  tags = {
    "Name"        = "${var.environment}-igw"
    "Environment" = var.environment
  }
}

# Elastic-IP (eip) for NAT
resource "aws_eip" "nat_eip" {
  vpc        = true
  depends_on = [aws_internet_gateway.ig]
}

# NAT Gateway
resource "aws_nat_gateway" "nat" {
  allocation_id = aws_eip.nat_eip.id
  subnet_id     = element(aws_subnet.public_subnet.*.id, 0)
  tags = {
    Name        = "nat-gateway-${var.environment}"
    Environment = "${var.environment}"
  }
}

As per the standard, we should have a NAT gateway on each AZ to access the internet without any issue in a situation like an unhealthy availability zone.

But here we are only creating a single NAT gateway with single elastic IP for the demo purposes.

Route tables – private and public subnets

# Routing tables to route traffic for Private Subnet
resource "aws_route_table" "private" {
  vpc_id = aws_vpc.vpc.id
  tags = {
    Name        = "${var.environment}-private-route-table"
    Environment = "${var.environment}"
  }
}

# Routing tables to route traffic for Public Subnet
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.vpc.id

  tags = {
    Name        = "${var.environment}-public-route-table"
    Environment = "${var.environment}"
  }
}

Configure public route to use internet gateway for internet access

# Route for Internet Gateway
resource "aws_route" "public_internet_gateway" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.ig.id
}

Configure private route to use a NAT gateway for internet access

# Route for NAT Gateway
resource "aws_route" "private_internet_gateway" {
  route_table_id         = aws_route_table.private.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_nat_gateway.nat.id
}

Associate route tables for subnets

Now we have subnets, route tables, and route table access to the internet, Now we can associate these route tables into the correct subnets.

route table for public subnets.

# Route table associations for both Public subnet
resource "aws_route_table_association" "public" {
  count          = length(var.public_subnets_cidr)
  subnet_id      = element(aws_subnet.public_subnet.*.id, count.index)
  route_table_id = aws_route_table.public.id
}

route table for the private subnet.

resource "aws_route_table_association" "private" {
  count          = length(var.private_subnets_cidr)
  subnet_id      = element(aws_subnet.private_subnet.*.id, count.index)
  route_table_id = aws_route_table.private.id
}

Now we have a correct mapping from VPC, subnet, and route table with NAT gateway and internet gateway.

So finally terraform configuration should be like the below,

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

  required_version = ">= 1.2.0"
}

provider "aws" {
  region = var.aws_region
}

locals {
  availability_zones = ["${var.aws_region}a", "${var.aws_region}b"]
}

# VPC
resource "aws_vpc" "vpc" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.environment}-vpc"
    Environment = var.environment
  }
}

# Public subnet
resource "aws_subnet" "public_subnet" {
  vpc_id                  = aws_vpc.vpc.id
  count                   = length(var.public_subnets_cidr)
  cidr_block              = element(var.public_subnets_cidr, count.index)
  availability_zone       = element(local.availability_zones, count.index)
  map_public_ip_on_launch = true

  tags = {
    Name        = "${var.environment}-${element(local.availability_zones, count.index)}-public-subnet"
    Environment = "${var.environment}"
  }
}

# Private Subnet
resource "aws_subnet" "private_subnet" {
  vpc_id                  = aws_vpc.vpc.id
  count                   = length(var.private_subnets_cidr)
  cidr_block              = element(var.private_subnets_cidr, count.index)
  availability_zone       = element(local.availability_zones, count.index)
  map_public_ip_on_launch = false

  tags = {
    Name        = "${var.environment}-${element(local.availability_zones, count.index)}-private-subnet"
    Environment = "${var.environment}"
  }
}

#Internet gateway
resource "aws_internet_gateway" "ig" {
  vpc_id = aws_vpc.vpc.id
  tags = {
    "Name"        = "${var.environment}-igw"
    "Environment" = var.environment
  }
}

# Elastic-IP (eip) for NAT
resource "aws_eip" "nat_eip" {
  vpc        = true
  depends_on = [aws_internet_gateway.ig]
}

# NAT Gateway
resource "aws_nat_gateway" "nat" {
  allocation_id = aws_eip.nat_eip.id
  subnet_id     = element(aws_subnet.public_subnet.*.id, 0)
  tags = {
    Name        = "nat-gateway-${var.environment}"
    Environment = "${var.environment}"
  }
}

# Routing tables to route traffic for Private Subnet
resource "aws_route_table" "private" {
  vpc_id = aws_vpc.vpc.id
  tags = {
    Name        = "${var.environment}-private-route-table"
    Environment = "${var.environment}"
  }
}

# Routing tables to route traffic for Public Subnet
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.vpc.id

  tags = {
    Name        = "${var.environment}-public-route-table"
    Environment = "${var.environment}"
  }
}

# Route for Internet Gateway
resource "aws_route" "public_internet_gateway" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.ig.id
}

# Route for NAT Gateway
resource "aws_route" "private_internet_gateway" {
  route_table_id         = aws_route_table.private.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_nat_gateway.nat.id
}

# Route table associations for both Public & Private Subnets
resource "aws_route_table_association" "public" {
  count          = length(var.public_subnets_cidr)
  subnet_id      = element(aws_subnet.public_subnet.*.id, count.index)
  route_table_id = aws_route_table.public.id
}

resource "aws_route_table_association" "private" {
  count          = length(var.private_subnets_cidr)
  subnet_id      = element(aws_subnet.private_subnet.*.id, count.index)
  route_table_id = aws_route_table.private.id
}

All done now we have the full VPC setup with all the necessary components to use whenever we need actual application deployments.

Please remember to remove the setup if you are no longer using it. since the NAT gateway and elastic IP are getting billed when in the ACTIVE stage.

$ terraform destroy

Conclusions

In this article, we have discussed How to Build AWS VPC Using Terraform – Step By Step Guide.

The implementation of all these examples and code snippets can be found in our Github repository.

Happy coding.

AWS Lambda Serverless CRUD API With Java

Chinthaka Dinadasa 🇱🇰 — Mon, 10 Apr 2023 07:48:07 +0000

AWS Lambda is Amazon Web Services (AWS) serverless computing platform that allows developers to run their code without building or managing servers. Java is one of the most popular programming languages supported by AWS Lambda. With the ability to use Java, developers can use their existing skills and libraries to build and deploy serverless applications on the AWS Lambda platform.

Java developers can take advantage of the flexibility and scalability of AWS Lambda by creating and running Java-based AWS Lambda functions. This process involves setting up the required environment, writing and testing the code, and deploying operations on the AWS Lambda platform. Using Java on AWS Lambda, developers can quickly build and deploy serverless applications that handle any traffic.

In this article, we will explain how we can build CRUD API with the following tech stack in a practical scenario,

Java 8
AWS Lambda
Serverless
DynamoDB

Requirement For REST API Development

In this article, we will develop serverless functions to support the following requirements for storing author data sets on DynamoDB tables with covering CRUD API functions.

Building Base Serverless Application

In this tutorial, we are going to use serverless CLI to create the application and manage the API infrastructure in later stages.

Creating a serverless application with Java 8 runtime

For the moment, serverless supports the following templates,

aws-java-gradle
aws-java-maven

Choose a maven or gradle java template as you prefer. We are going to use gradle based java application.

$ serverless create --template aws-java-gradle --path aws-lambda-serverless-crud-java

Basic project structure

com.serverless package – Here we are keeping all the sources and this is act as the base package for the project.
serverless.yml – With this, we can configure the serverless application infrastructure, API paths, Resources, environment variables, permissions and etc. Basically, serverless CLI uses this yml file to set up the cloud formation instructions for this application.
Handler – We can create handlers and point those from serverless.yml with an API endpoint (Optional). Basically, the handler acts as the starting point for the serverless API.

Configure distributions and other configs for the deployment – Optional step

By default the serverless application creates the distribution on build/distributions under hello.zip name.

We can change this and create and name the final distribution the way we like.

change the build.gradle as below under buildZip task.

task buildZip(type: Zip) {
    archiveBaseName = "aws-lambda-serverless-crud-java"
    from compileJava
    from processResources
    into('lib') {
        from configurations.runtimeClasspath
    }
}

Then change the distribution path in the serverless.yml,

package:
  artifact: build/distributions/aws-lambda-serverless-crud-java.zip

Also, we can configure the region and application stage we are going to deploy this application. Feel free to create your application with any region and stage.

provider:
  name: aws
  runtime: java8
  stage: development
  region: us-west-2

DynamoDB tables and permission to access from serverless

In this requirement, we have 2 ways to configure the database setup and create permissions which are a manual way and an automated way we can easily setup using serverless.yml

Let’s focus on the automated way we can configure via serverless.yml,

First, we need to create the DynamoDB table we need and add permissions to access the table from this serverless application. Here we are using an environment variable to set the database table, because it will make our life easier when we access the database at later stages.

provider:
  name: aws
  runtime: java8
  stage: development
  region: us-west-2

  environment:
    REGION: ${opt:region, self:provider.region}
    AUTHOR_TABLE: javatodev-author-${opt:stage, self:provider.stage}

Then the table definition,

resources:
  Resources:
    AuthorDynamoDBTable:
      Type: "AWS::DynamoDB::Table"
      Properties:
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: "id"
            AttributeType: "S"
        KeySchema:
          - AttributeName: "id"
            KeyType: "HASH"
        StreamSpecification:
          StreamViewType: "NEW_AND_OLD_IMAGES"
        TableName: ${self:provider.environment.AUTHOR_TABLE}

Now we have created the definitions to create the necessary dynamo DB tables on this application.

Then we need to give the necessary permissions to use these tables on application API processes.

provider:
  name: aws
  runtime: java8
  stage: development
  region: us-west-2

  # ENVIRONMENT VARIABLES
  environment:
    REGION: ${opt:region, self:provider.region}
    AUTHOR_TABLE: javatodev-author-${opt:stage, self:provider.stage}

  # IAM ROLES TO ACCESS DYNAMODB TABLES
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:Query
        - dynamodb:Scan
        - dynamodb:GetItem
        - dynamodb:BatchGetItem
        - dynamodb:PutItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
      Resource:
        - !GetAtt AuthorDynamoDBTable.Arn

Here we need to show the correct ARN to identify our table which was created with the application. We can point it using !GetAtt AuthorDynamoDBTable.Arn.

API Development

Now we can focus on developing API handlers and exposing those via HTTP API with AWS lambda serverless.

DTO / Utils and Other Classes

In this API, we use a separate Util class that converts incoming request body string to java POJO using Jackson ObjectMapper.

package com.serverless.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.serverless.exception.IncomingRequestParsingException;

public class RequestConversionUtil {

    ObjectMapper objectMapper = new ObjectMapper();

    public <T> T parseRequestBody(String requestBodyContent, Class<T> outPutClass) {
        try {
            return objectMapper.readValue(requestBodyContent, outPutClass);
        } catch (JsonProcessingException e) {
            throw new IncomingRequestParsingException();
        }
    }

}

Also, there are 2 main model classes we are using to bring data in and out from the API.

package com.serverless.model;

public class AuthorDto {

    private String id;
    private String firstName;
    private String lastName;
    private String email;
    private String identificationNumber;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getIdentificationNumber() {
        return identificationNumber;
    }

    public void setIdentificationNumber(String identificationNumber) {
        this.identificationNumber = identificationNumber;
    }

    @Override public String toString() {
        return "AuthorDto{" +
            "id='" + id + '\'' +
            ", firstName='" + firstName + '\'' +
            ", lastName='" + lastName + '\'' +
            ", email='" + email + '\'' +
            ", identificationNumber='" + identificationNumber + '\'' +
            '}';
    }
}

package com.serverless.model;

public class CommonAPIResponse {
    private String message;

    public CommonAPIResponse(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Base API Endpoint – GET

Just a simple JSON response with an incoming request.

functions:
  base_api:
    handler: com.serverless.Handler
    events:
      - httpApi:
          path: /
          method: get

package com.serverless;

import java.util.Collections;
import java.util.Map;

import org.apache.log4j.Logger;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;

public class Handler implements RequestHandler<Map<String, Object>, ApiGatewayResponse> {

    private static final Logger LOG = Logger.getLogger(Handler.class);

    @Override
    public ApiGatewayResponse handleRequest(Map<String, Object> input, Context context) {
        Response responseBody = new Response("Go Serverless v1.x! Your function executed successfully!", input);
        return ApiGatewayResponse.builder()
                .setStatusCode(200)
                .setObjectBody(responseBody)
                .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
                .build();
    }
}

Author Creation API Endpoint – POST

Here we are going to create an API endpoint that supports a POST HTTP method that allows us to bring requestBody with an incoming request.

  author_registration:
    handler: com.serverless.author.RegistrationHandler
    events:
      - httpApi:
          path: /authors/registration
          method: post

package com.serverless.author;

import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.ConditionalCheckFailedException;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.serverless.ApiGatewayResponse;
import com.serverless.Handler;
import com.serverless.model.AuthorDto;
import com.serverless.model.CommonAPIResponse;
import com.serverless.util.RequestConversionUtil;

import org.apache.log4j.Logger;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class RegistrationHandler implements RequestHandler<Map<String, Object>, ApiGatewayResponse> {

    private static final Logger LOG = Logger.getLogger(RegistrationHandler.class);
    private AmazonDynamoDB amazonDynamoDB;
    private String AUTHOR_DB_TABLE = System.getenv("AUTHOR_TABLE");
    private Regions REGION = Regions.fromName(System.getenv("REGION"));

    @Override public ApiGatewayResponse handleRequest(Map<String, Object> input, Context context) {
        RequestConversionUtil requestConversionUtil = new RequestConversionUtil();
        AuthorDto request = requestConversionUtil.parseRequestBody(input.get("body").toString(), AuthorDto.class);
        LOG.info("Incoming author registration request "+request.toString());
        this.initDynamoDbClient();
        persistData(request);
        return ApiGatewayResponse.builder()
            .setStatusCode(201)
            .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
            .setObjectBody(new CommonAPIResponse("Author registration successfully completed."))
            .build();
    }

    private String persistData(AuthorDto request) throws ConditionalCheckFailedException {
        String user_id = UUID.randomUUID().toString();
        Map<String, AttributeValue> attributesMap = new HashMap<>();
        attributesMap.put("id", new AttributeValue(user_id));
        attributesMap.put("firstName", new AttributeValue(request.getFirstName()));
        attributesMap.put("lastName", new AttributeValue(request.getLastName()));
        attributesMap.put("email", new AttributeValue(request.getEmail()));
        attributesMap.put("identification_number", new AttributeValue(request.getIdentificationNumber()));
        amazonDynamoDB.putItem(AUTHOR_DB_TABLE, attributesMap);
        return user_id;
    }

    private void initDynamoDbClient() {
        this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard()
            .withRegion(REGION)
            .build();
    }

}

Reading Environment Variables In AWS Lambda Java

In this API we are going to read REGION and table name from environment variables. This will make the developer’s life easier if we had to do a table name change in the future.

private String AUTHOR_DB_TABLE = System.getenv("AUTHOR_TABLE");

Sending JSON Response From AWS Lambda Java

By default, all the responses go from AWS lambda APIs using plain/text content type. Since we need to send all the responses as JSON to the consumers we have to set Content-type: application/json headers on all the API responses.

.setHeaders(Collections.singletonMap("Content-Type", "application/json"))

Read Author API Endpoint with FindAll and FindById – GET

  author_reads:
    handler: com.serverless.author.ReadHandler
    events:
      - httpApi:
          path: /authors
          method: get

package com.serverless.author;

import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
import com.amazonaws.services.dynamodbv2.model.ScanRequest;
import com.amazonaws.services.dynamodbv2.model.ScanResult;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.serverless.ApiGatewayResponse;
import com.serverless.model.AuthorDto;
import com.serverless.model.CommonAPIResponse;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ReadHandler implements RequestHandler<APIGatewayProxyRequestEvent, ApiGatewayResponse> {

    private AmazonDynamoDB amazonDynamoDB;
    private String AUTHOR_DB_TABLE = System.getenv("AUTHOR_TABLE");
    private Regions REGION = Regions.fromName(System.getenv("REGION"));


    @Override public ApiGatewayResponse handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        this.initDynamoDbClient();
        Map<String, String> queryParams = input.getQueryStringParameters();

        if (queryParams != null && queryParams.containsKey("findAll") && Boolean.parseBoolean(queryParams.get("findAll"))) {

            //Find All
            Map<String, AttributeValue> lastKeyEvaluated = null;
            List<AuthorDto> authorDtos = new ArrayList<>();
            do {
                ScanRequest scanRequest = new ScanRequest()
                    .withTableName(AUTHOR_DB_TABLE)
                    .withLimit(10)
                    .withExclusiveStartKey(lastKeyEvaluated);
                ScanResult result = amazonDynamoDB.scan(scanRequest);
                for (Map<String, AttributeValue> item : result.getItems()) {
                    authorDtos.add(mapToDto(item));
                }
                lastKeyEvaluated = result.getLastEvaluatedKey();
            } while (lastKeyEvaluated != null);

            return ApiGatewayResponse.builder()
                .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
                .setObjectBody(authorDtos).setStatusCode(200).build();

        } else if (queryParams!= null && queryParams.containsKey("id") && queryParams.get("id") != null) {

            //Find by id
            Map<String, AttributeValue> attributesMap = new HashMap<>();
            attributesMap.put("id", new AttributeValue(queryParams.get("id")));
            GetItemRequest getItemRequest = new GetItemRequest().withTableName(AUTHOR_DB_TABLE)
                .withKey(attributesMap);
            GetItemResult item = amazonDynamoDB.getItem(getItemRequest);

            return ApiGatewayResponse.builder()
                .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
                .setObjectBody(mapToDto(item.getItem())).setStatusCode(200).build();

        }

        return ApiGatewayResponse.builder()
            .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
            .setObjectBody(new CommonAPIResponse("No data found under given query"))
            .setStatusCode(200).build();

    }

    private AuthorDto mapToDto(Map<String, AttributeValue> item) {
        AuthorDto authorDto = new AuthorDto();
        authorDto.setId(item.get("id").getS());
        authorDto.setEmail(item.get("email").getS());
        authorDto.setFirstName(item.get("firstName").getS());
        authorDto.setLastName(item.get("lastName").getS());
        authorDto.setIdentificationNumber(item.get("identification_number").getS());
        return authorDto;
    }

    private void initDynamoDbClient() {
        this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard()
            .withRegion(REGION)
            .build();
    }

}

Using Query Parameters with AWS Lambda Java

Here we need to bring a query parameter to identify what users requesting to read from DB to switch between findAll and findById.

In this case, we can use APIGatewayProxyRequestEvent which bundles with the AWS core library, to capture these params easily from the incoming requests.

Map<String, String> queryParams = input.getQueryStringParameters();
queryParams.get("findAll");

Update Author Endpoint – PATCH

  author_update:
    handler: com.serverless.author.UpdateHandler
    events:
      - httpApi:
          path: /authors/{id}
          method: patch

Here we are bringing requestBody and author id as path parameters. We can capture both using APIGatewayProxyRequestEvent as we did in READ endpoint.

package com.serverless.author;

import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.UpdateItemRequest;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.serverless.ApiGatewayResponse;
import com.serverless.model.AuthorDto;
import com.serverless.model.CommonAPIResponse;
import com.serverless.util.RequestConversionUtil;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class UpdateHandler implements RequestHandler<APIGatewayProxyRequestEvent, ApiGatewayResponse> {
    private AmazonDynamoDB amazonDynamoDB;
    private String AUTHOR_DB_TABLE = System.getenv("AUTHOR_TABLE");
    private Regions REGION = Regions.fromName(System.getenv("REGION"));

    @Override public ApiGatewayResponse handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        initDynamoDbClient();
        RequestConversionUtil requestConversionUtil = new RequestConversionUtil();
        AuthorDto request = requestConversionUtil.parseRequestBody(input.getBody(), AuthorDto.class);

        Map<String, AttributeValue> keyMap = new HashMap<>();
        keyMap.put("id", new AttributeValue(input.getPathParameters().get("id")));

        UpdateItemRequest updateItemRequest = new UpdateItemRequest()
            .withTableName(AUTHOR_DB_TABLE)
            .addKeyEntry("id", new AttributeValue(input.getPathParameters().get("id")))
            .addAttributeUpdatesEntry("firstName",
                new AttributeValueUpdate(
                    new AttributeValue(request.getFirstName()),
                    AttributeAction.PUT))
            .addAttributeUpdatesEntry("lastName",
                new AttributeValueUpdate(
                    new AttributeValue(request.getLastName()),
                    AttributeAction.PUT))
            .addAttributeUpdatesEntry("email",
                new AttributeValueUpdate(
                    new AttributeValue(request.getEmail()),
                    AttributeAction.PUT))
            .addAttributeUpdatesEntry("identification_number",
                new AttributeValueUpdate(
                    new AttributeValue(request.getIdentificationNumber()),
                    AttributeAction.PUT));

        amazonDynamoDB.updateItem(updateItemRequest);

        return ApiGatewayResponse.builder()
            .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
            .setObjectBody(new CommonAPIResponse("Author update successfully completed")).build();
    }

    private void initDynamoDbClient() {
        this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard()
            .withRegion(REGION)
            .build();
    }
}

Delete Author API Endpoint – DELETE

  author_delete:
    handler: com.serverless.author.DeleteHandler
    events:
      - httpApi:
          path: /authors/{id}
          method: delete

package com.serverless.author;

import com.amazonaws.regions.Regions;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.serverless.ApiGatewayResponse;
import com.serverless.model.CommonAPIResponse;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class DeleteHandler implements RequestHandler<APIGatewayProxyRequestEvent, ApiGatewayResponse> {
    private AmazonDynamoDB amazonDynamoDB;
    private String AUTHOR_DB_TABLE = System.getenv("AUTHOR_TABLE");
    private Regions REGION = Regions.fromName(System.getenv("REGION"));

    @Override public ApiGatewayResponse handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        initDynamoDbClient();

        Map<String, AttributeValue> keyMap = new HashMap<>();
        keyMap.put("id", new AttributeValue(input.getPathParameters().get("id")));

        DeleteItemRequest request = new DeleteItemRequest()
            .withTableName(AUTHOR_DB_TABLE)
            .withKey(keyMap);
        amazonDynamoDB.deleteItem(request);

        return ApiGatewayResponse.builder()
            .setHeaders(Collections.singletonMap("Content-Type", "application/json"))
            .setObjectBody(new CommonAPIResponse("Author deletion successfully completed")).build();

    }

    private void initDynamoDbClient() {
        this.amazonDynamoDB = AmazonDynamoDBClientBuilder.standard()
            .withRegion(REGION)
            .build();
    }
}

Finally, the completed serverless.yml should look like below, ensure you have written the configurations yml in correct level.

service: aws-lambda-serverless-crud-java

frameworkVersion: '3'

provider:
  name: aws
  runtime: java8
  stage: development
  region: us-west-2

  # ENVIRONMENT VARIABLES
  environment:
    REGION: ${opt:region, self:provider.region}
    AUTHOR_TABLE: javatodev-author-${opt:stage, self:provider.stage}

  # IAM ROLES TO ACCESS DYNAMODB TABLES
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:Query
        - dynamodb:Scan
        - dynamodb:GetItem
        - dynamodb:BatchGetItem
        - dynamodb:PutItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
      Resource:
        - !GetAtt AuthorDynamoDBTable.Arn

resources:
  Resources:
    AuthorDynamoDBTable:
      Type: "AWS::DynamoDB::Table"
      Properties:
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: "id"
            AttributeType: "S"
        KeySchema:
          - AttributeName: "id"
            KeyType: "HASH"
        StreamSpecification:
          StreamViewType: "NEW_AND_OLD_IMAGES"
        TableName: ${self:provider.environment.AUTHOR_TABLE}

package:
  artifact: build/distributions/aws-serverless-crud-java.zip

functions:
  base_api:
    handler: com.serverless.Handler
    events:
      - httpApi:
          path: /
          method: get
  author_registration:
    handler: com.serverless.author.RegistrationHandler
    events:
      - httpApi:
          path: /authors/registration
          method: post
  author_reads:
    handler: com.serverless.author.ReadHandler
    events:
      - httpApi:
          path: /authors
          method: get
  author_update:
    handler: com.serverless.author.UpdateHandler
    events:
      - httpApi:
          path: /authors/{id}
          method: patch
  author_delete:
    handler: com.serverless.author.DeleteHandler
    events:
      - httpApi:
          path: /authors/{id}
          method: delete

All done now we have written the whole API with the necessary API endpoint exposing. We can deploy the API to AWS lambda.

$ serverless deploy

API Testings

We are using a Postman collection to test this API setup. You can sync the Postman collection with this link.

Conclusions

In this article, we have discussed how we can build a serverless API development using Java and DynamoDB and deploy with AWS lambda.

The implementation of all these examples and code snippets can be found in our GitHub repository.

Happy coding.

How to Configure AWS S3 Event Notification with Lambda

Chinthaka Dinadasa 🇱🇰 — Sun, 05 Mar 2023 02:30:00 +0000

AWS S3 supports event notifications, where you can set up notifications on specific events on an s3 bucket. Basically, this allows us to build application flows on an event that happens on the s3 bucket.

Overview of Amazon S3 Event Notifications

Currently, Amazon S3 can publish notifications for the following events:

Object created events
Object removal events
Restore object events
Reduced Redundancy Storage (RRS) object lost events
Replication events
S3 Lifecycle expiration events
S3 Lifecycle transition events
S3 Intelligent-Tiering automatic archival events
Object tagging events
Object ACL PUT events

In addition to that, Amazon S3 has the ability to send event notifications to the following destinations,

Amazon Simple Notification Service (Amazon SNS) topics
Amazon Simple Queue Service (Amazon SQS) queues
AWS Lambda function

Practical Implementation

As of now, we have a good understanding of the theoretical approach to how we can set up Amazon S3 event notifications. Let’s check how we can use these notifications in a practical scenario.

Requirement

EasyPhoto application allows its users to upload images using their web application, which will be stored on an s3 bucket. These images can be in various sizes and high resolutions. Hence there should be a lambda function that processes these uploads and create thumbnail images for all the uploads that EasyPhoto could use in the web application, which cost less data for web application users.

Lambda Function

Let’s start with setting up AWS lambda function that takes care of processing image files.

Here I’ve used serverless CLI for AWS to build this AWS Lambda function. If you don’t have CLI installed first configure it.

After that create a serverless application using the following commands,

$ serverless

Here we have to use HTTP Node.js — HTTP API, where we have the capability on processing incoming event notifications from Amazon S3.

Project structure,

Install necessary NPM modules to the application,

aws-sdk
sharp — If you are using macOS based development environment make sure you are using the following command to install sharp library since when installing sharp on MacOS via NPM the normal way (i.e.: npm i sharp --save), the installer automatically adds binaries for OS X. But AWS lambda functions run on Linux 2 machines with x64 processors, which makes issues in the lambda process.

Then we can build the function which processes images, Just copy the following code snippet into the hander.js.

"use strict";

const AWS = require('aws-sdk');
const sharp = require('sharp');

//AWS S3 Client
const s3 = new AWS.S3();

module.exports.processFile = async (event, context) => {

  const s3MetaData = event.Records[0].s3;
  const bucketName = s3MetaData.bucket.name;
  const processed = 'processed'
  const fileKey = s3MetaData.object.key;

  console.log(
    `S3 Metadata bucketname : ${bucketName} and uploaded file key : ${fileKey}`
  );

  try {
    const params = {
        Bucket: bucketName,
        Key: fileKey
    };
    console.log(`Original params ${JSON.stringify(params)}`);
    var origimage = await s3.getObject(params).promise();

  } catch (error) {
      console.log(error);
      return;
  }

  // set thumbnail width. Resize will set the height automatically to maintain aspect ratio.
  const width  = 200;

  // Use the sharp module to resize the image and save in a buffer.
  try {
      var buffer = await sharp(origimage.Body).resize(width).toBuffer();

  } catch (error) {
      console.log(error);
      return;
  }

  // Upload the thumbnail image to the destination bucket
  try {
    const destparams = {
        Bucket: bucketName,
        Key: `${processed}/${fileKey.split("/").pop()}`,
        Body: buffer,
        ContentType: "image"
    };

    console.log(`Destination params ${JSON.stringify(destparams)}`);

    const putResult = await s3.putObject(destparams).promise();

} catch (error) {
    console.log(error);
    return;
}

  console.log(`File conversion done ${bucketName} / ${fileKey} ${JSON.stringify(putResult)}`);

  return {
    statusCode: 200
  };
};

Here I’ve changed the default function name to processFile, Hence you need to change that on serverless.yml as well,

functions:
  processFile:
    handler: handler.processFile
    events:
      - httpApi:
          path: /
          method: get

As of now, we are ready with all the necessary function codes, But there is one more thing that we need to configure in this lambda function.

Here you can see we are accessing the S3 bucket and creating processed images on that bucket in this code sample. Hence this lambda function should have permission to execute getObject and putObject functions on that bucket.

We can supply these permissions through the same serverless.yml with the following code snippet.

provider:
  name: aws
  runtime: nodejs14.x
  timeout: 10
  stage: dev
iam:
    role:
      statements:
        - Effect: "Allow"
          Action:
            - "s3:GetObject"
            - "s3:PutObject"
          Resource: "arn:aws:s3:::<S3_BUCKET_NAME>/*"

Finally, the serverless.yml should look like the below,

service: image-processing-lambda
frameworkVersion: '3'

provider:
  name: aws
  runtime: nodejs14.x
  timeout: 10
  stage: dev

  iam:
    role:
      statements:
        - Effect: "Allow"
          Action:
            - "s3:GetObject"
            - "s3:PutObject"
          Resource: "arn:aws:s3:::<S3_BUCKET_NAME>/*"

functions:
  processFile:
    handler: handler.processFile
    events:
      - httpApi:
          path: /
          method: get

All done, then we can deploy the lambda function on AWS lambda using the following command,

$ serverless deploy

Now we are ready with our lambda function and we can now focus on S3 bucket configurations.

S3 Bucket

As I mentioned earlier, we should have 2 folders under the same bucket to put uploads, and then store processed file.

Then we can set up event notification to send object creation notifications to the lambda we deployed.

Goto properties -> Event Notifications -> Create event notification

choose All object to create events event from event types, then choose deployed lambda function from the destination,

All done, now we have successfully configured S3 bucket to send event upload notifications to post-processing through a serverless application.

You can simply test the application using the S3 dashboard, and upload any kind of image file to the uploads bucket, Then lambda function will do the post processing and store the result in processed folder under that same bucket.

Wrapping Up

Thanks for reading this article on how we can configure amazon s3 event notifications and post process those images automatically using AWS Lambda serverless application.

You can find all the source codes from Github.

Feel Free to write down your views. 👐

Deploy Spring Boot Application On AWS Elastic Beanstalk

Chinthaka Dinadasa 🇱🇰 — Sat, 04 Mar 2023 06:04:22 +0000

AWS Elastic Beanstalk is a fully managed service that makes it easy to deploy, run, and scale web applications and services in the AWS Cloud. When deploying Spring Boot applications, AWS Elastic Beanstalk is an excellent choice as it provides a simple and cost-effective way to run and scale Java web applications without worrying about the underlying infrastructure.

The Elastic Beanstalk service is fully integrated with the Spring Boot framework, which allows you to deploy Spring Boot applications with minimal configuration quickly.

Spring Boot Application We Are Going To Deploy

Here, I’ve developed minimal REST API with Spring Boot, Java 17, JPA, and H2 In-memory database. You can clone it from this repository.

This API has a single endpoint where it reads the countries list from the H2 database and is exposed with the following URL or feel free to use any spring boot application you have access to.

Deployment Flow

Let’s start the deployment of our Spring Boot application on AWS elastic beanstalk and expose that through a public URL.

Using Elastic Beanstalk CLI

In this tutorial, I’m going to use Elastic Beanstalk CLI which allows us to simply access the elastic beanstalk product on AWS and create any kind of environment we like.

Also, there is another way we can use the AWS dashboard to achieve the same target.

You can refer to this official documentation in order to set up EB CLI on your development machine.

Setting Up Application On Elastic Beanstalk

First, we should create a new application and deployment environment on the elastic beanstalk. We can achieve that by executing the following command on the project root.

$ eb init

then choose the preferred AWS region and application name to create the deployment environment.

Here I’ve used us-west-2: US West (Oregon) for demonstration purposes.

After completing this step you should ask to choose the platform, Here it should be Java, and choose the java version which matches your application, For me, it is Java – Corretto 17 running on 64bit Amazon Linux 2.

Finally, there will be asked to set up CodeCommit and set up SSH access to the EC2 instances that this setup will create. But for the moment I’m not going to set up those.

So now we should have elastic beanstalk config.yml created on project root with config as below.

branch-defaults:
  main:
    environment: null
global:
  application_name: spring-boot-elastic-beanstalk
  branch: null
  default_ec2_keyname: null
  default_platform: Corretto 17 running on 64bit Amazon Linux 2
  default_region: us-west-2
  include_git_submodules: true
  instance_profile: null
  platform_name: null
  platform_version: null
  profile: null
  repository: null
  sc: git
  workspace_type: Application

Configure JAR File For Elastic Beanstalk Deployment
By default, EB CLI uses git history and creates zip file to with the latest application code when deploying. But that will not work with the spring boot application since it should be deployed using JAR file build on application build folders.

We need to show that specific JAR build in order to deploy on the elastic beanstalk. We can achieve that by adding the following into the .elasticbeanstalk/config.yml.

Here I’m using Gradle for application build, it creates the application JAR build on /build/libs/ folder on project root.

deploy:
  artifact: build/libs/spring-boot-elastic-beanstalk-0.0.1-SNAPSHOT.jar

Setting Up Deployment Environment and Process Initial Deployment

Now, we can deploy our JAR build on the EB environment, with the following command,

$ eb create

choose environment name, DNS name prefix which will used to expose our API with domain name and load balancer type.

Here I’ve used an application load balancer and skipped creating a spot instance fleet.

Here you should see EB CLI started to deploy your JAR built on AWS, and it should be started to upload with above command.

Setting Application Ports To Expose With Public URL

Since we are using the default port with the spring boot application, It runs on port 8080. But elastic beanstalk uses nginx internally and it routes public domain entry into port 5000. Hence we have to set up our application to run with port 5000 with the following command.

$ eb setenv SERVER_PORT=5000

Now our deployment should be done, and we could access our API through the public URL published on the elastic beanstalk dashboard.

Access the API using public URL and /api/v1/countries and it should return following JSON reponse.

Benefits Of Using Elastic Beanstalk

One of the key benefits of using AWS Elastic Beanstalk for Spring Boot applications is that it abstracts away the underlying infrastructure so you don’t have to worry about provisioning and managing servers.

The service automatically provisions and scales the infrastructure to match the number of requests and the amount of traffic your application receives, taking care of all the underlying infrastructure for you. This allows you to focus on developing and deploying your application without worrying about the operational aspect of running it. Additionally, with the simple and cost-effective pricing model, it’s a great option for deploying and running Spring Boot applications on the cloud.

Conclusions

In this article, we have discussed how we can deploy a spring boot application on AWS elastic beanstalk in a practical scenario.

The implementation of all these examples and code snippets can be found in our GitHub repository.

Happy coding.

DEV Community: Chinthaka Dinadasa 🇱🇰

Deploying Spring Boot Applications With AWS ECS Fargate (Free Course)

What Are We Going To Build

Article Series

How to Build AWS VPC Using Terraform - Step By Step

The architecture we are going to setup

Prerequisites

Initiate Terraform Configuration

Basic Terraform Commands

Define input variables for Terraform

Define provider with an AWS region

Local Values

Define VPC and other components

VPC – Virtual Private Network

Private and Public Subnets Inside VPC

Internet Gateway and NAT Gateway

Route tables – private and public subnets

Configure public route to use internet gateway for internet access

Configure private route to use a NAT gateway for internet access

Associate route tables for subnets

Conclusions

AWS Lambda Serverless CRUD API With Java

Requirement For REST API Development

Building Base Serverless Application

Creating a serverless application with Java 8 runtime

Basic project structure

Configure distributions and other configs for the deployment – Optional step

DynamoDB tables and permission to access from serverless

API Development

DTO / Utils and Other Classes

Base API Endpoint – GET

Author Creation API Endpoint – POST

Reading Environment Variables In AWS Lambda Java

Sending JSON Response From AWS Lambda Java

Read Author API Endpoint with FindAll and FindById – GET

Using Query Parameters with AWS Lambda Java

Update Author Endpoint – PATCH

Delete Author API Endpoint – DELETE

API Testings

Conclusions

How to Configure AWS S3 Event Notification with Lambda

Overview of Amazon S3 Event Notifications

Practical Implementation

Requirement

Suggested Solution

Lambda Function

S3 Bucket

Wrapping Up

Deploy Spring Boot Application On AWS Elastic Beanstalk

Spring Boot Application We Are Going To Deploy

Deployment Flow

Using Elastic Beanstalk CLI

Setting Up Application On Elastic Beanstalk

Setting Up Deployment Environment and Process Initial Deployment

Setting Application Ports To Expose With Public URL

Benefits Of Using Elastic Beanstalk

Conclusions