DEV Community: Long Ngo

API Gateway integrate privately with ECS microservice

Long Ngo — Sun, 05 Nov 2023 15:18:14 +0000

This post noted some steps for configuring AWS API Gateway work with ECS to work with microservices. Some AWS services are used like API Gateway, ELB, ECS, VPC.

In summary, the steps contain of:

Create VPC.
Create ECS service target group and attach it with ALB.
Create ECS cluster and run services.
Create ALB target group and attach to NLB.
Create API gateway for REST API, and point the gateway to NLB using VPC Link.

1. Create VPC

Create a VPC with 2 public and 2 private subnets, 1 internet gateway and 1 NAT gateway

Check the route table of both private subnets to make sure an instance of the private subnet can go to the internet through the NAT gateway. Correctly, route table will have a route for destination is 0.0.0.0/0.

2. Create ECS service target group and attach it with ALB
Create a Target Group with IP addresses target type, place the group to created VPC. Other options are leave by default. One target group correspond with one microservice, you need to create many target group and configure each target group with a rule on listener of ALB.

Next, create an ALB with internal scheme, point the listener on port 80 to the created target group. Make sure the ALB nodes are placed at 2 private subnets, and using the default security group.

3. Create ECS cluster and run services
Create an ECS cluster with Fargate launch type. Next, create a task definition which has one container for demo purpose, using the Nginx docker image. In real world, this docker image will be replicated by a microservice docker image.
The task definition has Fargate launch type, Linux/X86_64 OS, 0.5 CPU and 1 GB RAM. Task also has some specific configurations, follow the below images. Others are to leave by default.

After creating task definition, we create a service for cluster. At environment, choose Launch type for Compute option. At deployment configuration, choose Service for Application type. Then open the net work configuration, choose created VPC and exclude 2 public subnets, only use 2 private subnets. Security group is default.

Next, open the Load Balancing and attach this service with created target group and ALB.

After creating service, it takes some time for status will be changed to Active. Then, checking the target group associate with ALB, we will see one healthy target.

4. Create ALB target group and attach to NLB
We create another target group with target type is ALB, place it to created VPC. Then we register the created ALB to target group. Next, we create NLB and associate NLB to the created ALB target group.
For network configuration, we also use created VPC and 2 private subnets.

Checking the ALB target group, we have one healthy target.

5. Create API gateway for REST API, and point the gateway to NLB using VPC Link
Move to the API Gateway and create a Rest API, choose new API and REST protocol. Then go to the VPC and create a new one, point it to created NLB.

We need to wait for the status change to Available. At this time, we go to the API and create a proxy resource with GET method and setup request integration. In the real world, you need to add the {proxy+} to your endpoint URL to match with context path of API endpoint. Proxy resource help ALB distribute request to correct microservice host on ECS cluster.

Then we deploy gateway to a stage, on this stage we configure some variable.

If the VPC Link status changed to Available, we go back to the NLB and update the security group to allow request from API gateway to NLB.
Creating a new security group and add one inbound rule

At NLB security configuration, attach the created security group to it and uncheck the Enforce inbound rule on PrivateLinks traffic.

Finally, go to the API Gateway and take the link of the stage. Open this link on a new browser tab and add /nginx path to the link, we will see the ECS service response.

Lazy load caching strategy example using Redis

Long Ngo — Sat, 01 Apr 2023 11:03:41 +0000

1. Introduction

Caching data is a very interested topic along with performance of system. There are very strategies to implement caching that you can hear at somewhere: write-through, write-back, read-through, cache-aside,... Today, we will create the simplest example for lazy-load also known as a cache-aside strategy by Spring Boot, MongoDB and Redis.

Redis is an open-source, in-memory data structure store, often used as a database, cache, and message broker. Redis is regularly used in web applications to cache frequently accessed data and reduce the number of database queries, thereby improving performance.
MongoDB is a popular, open-source NoSQL document-oriented database that is designed to store and manage unstructured data. Instead of using tables and rows like traditional relational databases, MongoDB stores data as JSON-like documents with dynamic schemas, which means that each document can have its own unique structure and fields.

In this example, we not use self-managed for Redis. Instead of, we will use AWS ElastiCache Redis. This is a service that AWS provide that can help us reduce much time to set up Redis server on local machine.

2. Implementation

2.1. Create AWS resources
We need to create Redis cluster. You can refer this below link for step-by-step guide: https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/GettingStarted.CreateCluster.html#Clusters.Create.CON.Redis-gs

After creating resource, we have one Redis cluster. Information of resources like this

2.2. Create Spring Boot project
In this demo, we will create APIs to interact with a local MongoDB instance and Redis remote server hosted in AWS. You can use the Spring Start Project in Eclipse or Spring Initializer to create a Spring Boot project. These are required maven dependencies that you must add to POM file in our example.



<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

2.3. Create API to interact with MongoDB & Redis
To work with AWS Elasticache Redis server, we need to add some configurations to property file



spring.data.redis.host=<redis-primary-endpoint>
spring.data.redis.port=<redis-port>

You must replace the placeholder by your Redis primary endpoint and port, default port normally is 6379. After adding configurations, we create a Bean to interact with Redis server by Redis template.



@Bean
public LettuceConnectionFactory redisConnectionFactory() {
  return new LettuceConnectionFactory();
}

@Bean
RedisTemplate < String, Object > redisTemplate(RedisConnectionFactory redisConnectionFactory) {

  RedisTemplate < String, Object > template = new RedisTemplate < > ();
  template.setConnectionFactory(redisConnectionFactory);
  return template;
}

Now, creating an entity named is Product and this entity has some attributes like this



@Document("product")
@Data
public class Product {

    private String id;
    private String name;
    private String category;
    private int quantity;
}

And, we create a data access object that directly work with database and cache from application.



// function work with MongoDB

    public Product addProduct(Product p) {
        return mongoTemplate.save(p);
    }

    public Product getProductById(String id) {
        Class<?> productClass = Product.class;
        Product product = (Product) mongoTemplate.findById(id, productClass);
        log.info("Got product from Database {}", product);
        return product;
    }



// function work with Redis

public ValueOperations < String, Object > addProductToRedis(Product p) {
  try {
    ValueOperations < String, Object > cachedProduct = redisTemplate.opsForValue();
    objectMapper = getObjectMapper();
    Map < ? , ? > map = objectMapper.convertValue(p, Map.class);
    cachedProduct.set(p.getId(), map, 10, TimeUnit.SECONDS);
    log.info("Add product to cache {}", map);
    return cachedProduct;
  } catch (RedisConnectionFailureException e) {
    log.info("Cannot add product, Redis service go down...");
  }

  return null;

}

public Product getProductFromRedis(String key) {

  ValueOperations < String, Object > cachedProduct = redisTemplate.opsForValue();
  try {
    Object result = cachedProduct.getAndExpire(key, 10, TimeUnit.SECONDS);
    objectMapper = getObjectMapper();
    Product product = objectMapper.convertValue(result, Product.class);
    log.info("Got product from cache {}", product);
    return product;
  } catch (RedisConnectionFailureException e) {
    log.info("Cannot get product, Redis service go down...");
  }

  return null;
}

Then, creating a service to invoke functions in DAO layer



public Product addProduct(Product p) {
  return productDao.addProduct(p);
}

public Product getProductById(String id) {
  Product product = productDao.getProductFromRedis(id);
  if (product == null) {
    product = productDao.getProductById(id);
    productDao.addProductToRedis(product);

  }

  return product;
}

The getProductById function has logic that follow with the strategy like this

When Spring App needs to read data from MongoDB, it checks the cache in Redis first to determine whether the data is available.
If the data is available (a cache hit), the cached data is returned, and the response is issued to the caller.
If the data isn’t available (a cache miss), the database is queried for the data. The cache is then populated with the data that is retrieved from the database, and the data is returned to the caller.

Moreover, because we don't want to store data that not be frequently access, store infrequently accessed data is waste. So, we will add a Time To Live (TTL) for each data which be initially cached by 10 seconds. And for every time this data be accessed, we refresh the TTL value. In the above code, you can see we already used getAndExpire method to accomplish this idea.

Finally, we create some endpoints to test our functions



@PostMapping("/products")
public Product addProduct(@RequestBody Product p) {
  return productService.addProduct(p);
}

@GetMapping("/products/{id}")
public Product getProduct(@PathVariable String id) {
  return productService.getProductById(id);
}

2.4. Testing API
For testing purpose, we use Postman to create a product

Then, getting the product by ID and view the log in Eclipse console

Because this is the first time to get product, you can see Redis return null value and database was being queried to get product. Afterward, product is added to Redis. We also see the time that API respond is 731ms. Now, we test to see how much time to take response with Redis

Only 8ms and by the log we can confirm product was got from cache instead of database.

3. Summary

We already implemented an example for Lazy-loading also known as Cache-Aside strategy caching using AWS Elasticache Redis. We can see the performance was significantly increased by caching. But it just is the simplest example to give a viewing for implement caching approach. To use it in the real world, for a large system, we must handle many situations that can occur like Redis goes down, memory fragmentation issues, TTL management,...

The implementation of all these examples can be found in my GitHub

References: https://docs.aws.amazon.com/whitepapers/latest/database-caching-strategies-using-redis/caching-patterns.html

Happy Coding :)

Upload large file with Multipart Upload feature

Long Ngo — Sat, 11 Mar 2023 07:40:57 +0000

1. Introduction

AWS S3 (Simple Storage Service) is an object storage service. It allows users to store and retrieve data from anywhere on the web. S3 is designed for businesses of all sizes and can store a virtually unlimited number of objects, including photos, videos, log files, backups, and other types of data.

S3 multipart upload is a feature that allows you to upload large objects in parts (i.e., chunks) instead of uploading the entire object in a single HTTP request. It is particularly useful when uploading very large files. With multipart upload, you can upload individual parts of the object in parallel, which can significantly speed up the overall upload process.

2. Implementation

2.1. Provide access and create S3 bucket
First, we need to provide access to AWS for the IDE, where we are implementing this example. So, if you don't know anyway, you can refer to my previous post, in the 2.1 section.

Next, we create a S3 bucket to store some files. I will name my bucket is multipart-uploading0924. You need named a difference name for your one. Because the S3 bucket name is unique in global.

2.2. Setup Spring boot project
In this demo, we will create an API that can upload files to S3 bucket. You can use the Spring Start Project in Eclipse or Spring Initializer to create a Spring Boot project. After that, we need to add this dependency to POM file.



<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-s3</artifactId>
    <version>1.12.424</version>
</dependency>

2.3. Create API endpoints using to upload file
I want to show you the better performance when using multipart upload feature of S3. So we will create 2 function, one for normal uploading and another for multipart uploading.

First, creating a S3 client that will interact with created bucket. You must change the name of the profile you already set up, and the region where you place the bucket in below code. In this case, longngo0924 is a profile that I will use to create S3 client and my bucket is placed in ap-southeast-2 region (Sydney)



private AmazonS3 getS3ClientInstance() {
        if (s3client != null)
            return s3client;
        return AmazonS3ClientBuilder.standard().withCredentials(new ProfileCredentialsProvider("longngo0924"))
                .withRegion(Regions.AP_SOUTHEAST_2).build();
    }

We create a function in service layer with the name is uploadFileV1. This function corresponding for normal upload type, and we write some code like this.



public Map<String, String> uploadFileV1(MultipartFile multipartFile) throws IllegalStateException, IOException {

        Map<String, String> map = new HashMap<>();

        s3client = getS3ClientInstance();

        File file = convertToFile(multipartFile);

        PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, file.getName(), file);

        long start = System.currentTimeMillis();

        PutObjectResult result = s3client.putObject(putObjectRequest);

        long end = System.currentTimeMillis();
        log.info("Complete Normal Uploading {}s", (end - start) / 1000);

        if (result != null) {
            map.put("fileSize", String.valueOf(multipartFile.getSize() / 1000000) + "MB");
            map.put("time", String.valueOf((end - start) / 1000) + "s");
        } else {
            map.put("message", "Upload Failed");

        }
        return map;
    }

In the above function, we receive a multipart file from controller layer. Then, we convert it to file and construct a put object request call to S3.

The second function will be named is uploadFileV2. This function is similar with the first. The difference is we will upload file in parallel with multi thresh, every thresh upload a partial of our file. And the implemented code like this.



public Map<String, String> uploadFileV2(MultipartFile multipartFile)
            throws IOException, AmazonServiceException, AmazonClientException, InterruptedException {
        Map<String, String> map = new HashMap<>();
        s3client = getS3ClientInstance();

        File file = convertToFile(multipartFile);

        TransferManager tm = TransferManagerBuilder.standard().withS3Client(s3client)
                .withMultipartUploadThreshold((long) (50 * 1024 * 1025)).build();

        long start = System.currentTimeMillis();
        Upload result = tm.upload(bucketName, file.getName(), file);
        result.waitForCompletion();
        long end = System.currentTimeMillis();
        log.info("Complete Multipart Uploading {}s", (end - start) / 1000);

        map.put("fileSize", String.valueOf(multipartFile.getSize() / 1000000) + "MB");
        map.put("time", String.valueOf((end - start) / 1000) + "s");

        return map;

    }

You can see our file being cut into piece with size is 50 MB. One point in here, the upload method of TransferManager is non-blocking and returns immediately. So we need to use waitForCompletion method to wait the response if we need.

Finally, we add some endpoints in controller layer to receive uploading request.



@PostMapping("/v1/uploading")
    public Map<String, String> uploadFileV1(@RequestParam MultipartFile file)
            throws IllegalStateException, IOException {

        return uploadFileService.uploadFileV1(file);
    }

    @PostMapping("/v2/uploading")
    public Map<String, String> uploadFileV2(@RequestParam MultipartFile file)
            throws IllegalStateException, IOException,
            AmazonServiceException, AmazonClientException, InterruptedException {

        return uploadFileService.uploadFileV2(file);
    }

2.4. Upload file to S3 bucket
For testing purpose, we use Postman to test implemented APIs. First, we will use the endpoint corresponding for normal upload function and upload a 200 MB size file

And for now, we test the endpoint for multipart upload

We can see with the same 200 MB file, the multipart upload function have the better performance than normal upload function. Speed is twice as fast in this example. And there are files we already uploaded by APIs.

3. Summary

Using S3 Multipart Uploading feature, the upload process will have better performance and this benefit is significant for an application need to upload large file regularly. Additionally, if any part of the upload fails, you only need to re-upload that specific part rather than the entire object. This can save time and bandwidth.

The implementation of all these examples can be found in my GitHub

Happy Coding :)

Integrate Spring boot Version 3 with Parameter Store

Long Ngo — Sat, 04 Mar 2023 13:02:16 +0000

1. Introduction

AWS Parameter Store is a service provided by Amazon Web Services (AWS) that help us store and manage parameters and secrets for our applications. It provides a secure, centralized location for storing and accessing sensitive data such as database credentials, API keys, and configuration data.
So we can use this service to manage multiple deployment property files for a Spring Boot Application.

2. Implementation

2.1. Provide access to the development environment
We need to provide access key and secret key for IDE (I will use Eclipse) to access the Parameter Store feature. You can refer this post AWS Toolkit for Eclipse and follow these steps to install AWS Toolkit for Eclipse IDE.

After install successfully, we need to add key pair into AWS Toolkit. You can click the Icon of AWS Toolkit on the header and choose Preferences. If you are already had an access key on your computer, it will be display like this.

If you don't want to use this key, you can add manually another key by press the plus button next to the Global Configuration.

2.2. Create a Spring boot project
We can use Spring Starter Project from Spring Tool Suite (can find at Eclipse Marketplace) or Spring Initializer to create a Spring boot project with Spring boot version 3
Then, we should add some dependency that need to use to integrate with Parameter Store.



<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-aws-parameter-store-config</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>

Carefully check you add these dependencies exactly. Because for a Spring Boot version 3, we should use spring-cloud-starter-bootstrap to work with Parameter Store. If you don't use it, the issues relative to mismatch version can occur. And finally, we need to use spring-cloud-dependencies because Parameter Store work on Spring Cloud.



<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2022.0.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2.3. Read the parameter from Parameter Store
We need to define application name in application.properties file. For example is spring.application.name=my-app. By default, Spring defined the syntax to work with parameter on Parameter Store with format:
/config/<name-of-the-spring-application>_<profile>/<parameter-name>
If the default parameter convention does not fit our needs. We can create a bootstrap.properties to override.



aws.paramstore.enabled=true
aws.paramstore.prefix=/demo
aws.paramstore.name=my-app
aws.paramstore.profileSeparator=

Now, we will create some parameter and add some code for testing.
In the AWS Console of AWS System Manager, you can choose Parameter and click on Create Parameter button.

I already have some parameters in there, so I don't create anymore. You can create by input the name of parameter.

Select the type, recommend for SecureString.

And finally, input the value for this parameter.

For testing purpose, the @Value annotation will be used to resolve the value of parameters. We expect the port variable will have value of /demo/my-app/spring.port and message variable corresponding for /demo/my-app/spring.message.



@SpringBootApplication
@Slf4j
public class DemoApplication implements CommandLineRunner {

    @Value("${spring.port}")
    private String port;

    @Value("${spring.message}")
    private String message;


    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);

    }

    @Override
    public void run(String... args) throws Exception {

        log.info("Resolved message port: {}", port);
        log.info("Resolved message parameter: {}", message);


    }

}

Starting the application and view on the console log, we can see the value that we created on AWS Parameter Store

3. Summary

Using the Parameter Store with Spring Boot application, we can manage the value of properties easily. It can work similar to read values from application.properties file by @Value annotation. Also help to reduce the mismatch issues between development processing in local environment and deploy processing on AWS Cloud.

The implementation of all these examples can be found in my GitHub

Happy Coding :)