Guided Exercise - Spring Microservices - Proxy Pattern | (Extra - Spring Cloud Gateway & Netflix Zuul)

[akash-coded]

Part-1

Scenario:

Imagine an e-commerce application with the following microservices:

1. ProductService: Manages product information.
2. OrderService: Manages customer orders.
3. InventoryService: Keeps track of the stock/inventory for each product.

Now, the OrderService needs to fetch product details from ProductService and update inventory in the InventoryService after each order.

We will use a proxy to isolate direct calls between these services, to decouple them and ensure clean separation of concerns.

---

1. Concepts:

• Proxy Pattern: In the context of microservices, a proxy is an intermediate that acts as both a server and a client for the purpose of making requests on behalf of other clients. It can be used for load balancing, monitoring, logging, security, etc.

• Spring Boot Microservices: Microservices are smaller, independent applications that work together. Spring Boot makes it easy to create stand-alone, production-grade applications.

---

2. Product Service

Repository Structure:

product-service/
│
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/tcs/productservice/
│   │   │       ├── controller/
│   │   │       ├── model/
│   │   │       ├── repository/
│   │   │       └── service/
│   │   │
│   │   └── resources/
│   │       └── application.properties
│   │
│   └── test/
│
├── pom.xml
│
└── .gitignore

application.properties:

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/products_db
spring.datasource.username=root
spring.datasource.password=root

Product.java:

package com.tcs.productservice.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Double price;

    // getters, setters, constructors
}

ProductRepository.java:

package com.tcs.productservice.repository;

import com.tcs.productservice.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

ProductService.java & ProductController.java:
Provide basic CRUD for managing products.

---

3. Inventory Service

Follow a similar structure and CRUD for managing inventory.

---

4. Order Service

Here's where it gets interesting. This service will act as a client for the other two services, either directly or via a proxy.

Direct Calls without Proxy:

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;

    @PostMapping("/")
    public ResponseEntity<String> placeOrder(@RequestBody OrderRequest orderRequest) {
        // Direct call to ProductService
        Product product = restTemplate.getForObject("http://localhost:8081/products/" + orderRequest.getProductId(), Product.class);

        // Logic for placing order

        // Direct call to InventoryService to update inventory
        restTemplate.postForEntity("http://localhost:8082/inventory/update", updateRequest, Void.class);

        return ResponseEntity.ok("Order Placed Successfully");
    }
}

Using Proxy:

A proxy can be introduced here to avoid direct calls. This proxy can add additional features like logging, security, etc.

public class ProductServiceProxy {

    @Autowired
    private RestTemplate restTemplate;

    public Product getProduct(Long productId) {
        // You can add logging, metrics collection, etc. here

        return restTemplate.getForObject("http://localhost:8081/products/" + productId, Product.class);
    }

    // Similarly, other proxy methods
}

The OrderController will now use ProductServiceProxy instead of direct calls.

---

5. Best Practices & Additional Tips:

• Always handle exceptions gracefully.
• Ensure meaningful logging.
• For advanced scenarios, consider using Spring Cloud Gateway or Netflix Zuul as a proxy gateway.
• Use Spring Cloud Circuit Breaker for handling failures.

---

Wrap Up:

By introducing the proxy pattern in the context of microservices, we can achieve separation of concerns, cleaner code, and additional features like logging, security, and more. The above exercise should provide a good starting point for TCS engineers with 2-8 years of experience in Spring Boot.

---

Part-2

We'll dive into using both Spring Cloud Gateway and Netflix Zuul to further explore the proxy pattern, especially in the context of microservices. We'll also integrate different tasks around the benefits and limitations of the proxy pattern.

7. Introduction to Spring Cloud Gateway & Netflix Zuul

Both Spring Cloud Gateway and Netflix Zuul provide API gateway capabilities. While Zuul was the initial solution provided by Netflix, Spring Cloud Gateway offers a more modern approach and is often considered the successor.

Zuul:

• Provides functionalities like routing requests, load balancing, security, metrics, etc.
• Filters mechanism for pre-request and post-request handling.

Spring Cloud Gateway:

• Built on top of Project Reactor, it's non-blocking and better suited for microservices architectures.
• Provides features like route definition, rate limiting, and resilience patterns.

---

8. Setting Up Netflix Zuul

Dependencies:
Include the following in the pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

application.properties:

server.port=8765
zuul.routes.product-service=/product-service/**
zuul.routes.inventory-service=/inventory-service/**

Here, we're setting up routes that will forward requests to the respective microservices.

Main Application Class:

@EnableZuulProxy
@SpringBootApplication
public class ZuulGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulGatewayApplication.class, args);
    }
}

---

9. Setting Up Spring Cloud Gateway

Dependencies:
Include these in the pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

application.properties:

server.port=8888

spring.cloud.gateway.routes[0].id=product-service
spring.cloud.gateway.routes[0].uri=http://localhost:8081
spring.cloud.gateway.routes[0].predicates[0]=Path=/product-service/**

spring.cloud.gateway.routes[1].id=inventory-service
spring.cloud.gateway.routes[1].uri=http://localhost:8082
spring.cloud.gateway.routes[1].predicates[0]=Path=/inventory-service/**

---

10. Tasks & Scenarios

Task 1 - Third-Party Consumers via Gateway:
Consider you want to expose the ProductService to third-party vendors but with rate-limiting.

• Zuul: Use Zuul Filters to implement rate-limiting.
• Spring Cloud Gateway: Use the built-in RequestRateLimiter filter.

Task 2 - Service Aggregation:
Third-party vendors need aggregated data from both ProductService and InventoryService. Create an endpoint in the Gateway that fetches data from both services and returns a combined response.

Task 3 - Custom Filters:

• Zuul: Create a custom pre-filter that logs the request details before forwarding.
• Spring Cloud Gateway: Create a custom global filter for logging.

Task 4 - Error Handling & Fallback:
Introduce a mechanism in the Gateway to handle errors gracefully, providing default responses if a service is unavailable.

Task 5 - Drawbacks & Limitations:

• Scenario 1: Microservices have their unique authorization. Implement a system where the Gateway handles unified authentication, but individual authorization still lies with microservices. Discuss the added complexity.
• Scenario 2: A new version of InventoryService is launched. Implement versioning in Gateway and discuss the challenges of managing multiple versions.

Detailed Implementation Guidelines for the Tasks

Alright, let's dive deeper into each task, providing a detailed step-by-step guide.

---

Task 1 - Third-Party Consumers via Gateway

Objective: Expose the ProductService to third-party vendors but limit the rate at which they can access it.

1. Zuul Rate Limiting:

   a. Add the required dependencies:

   <dependency>
       <groupId>com.marcosbarbero.cloud</groupId>
       <artifactId>spring-cloud-zuul-ratelimit</artifactId>
       <version>LATEST_VERSION</version>
   </dependency>

   b. In application.properties:

   zuul.ratelimit.enabled=true
   zuul.ratelimit.policy-list.product-service[0].limit=10
   zuul.ratelimit.policy-list.product-service[0].refresh-interval=60

   This will limit the ProductService to 10 requests per minute.

2. Spring Cloud Gateway Rate Limiting:

   a. Add Redis as a backend for rate limiting:

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
   </dependency>

   b. In application.properties:

   spring.redis.host=localhost
   spring.redis.port=6379

   c. Configure rate limiter in the route definition:

   spring.cloud.gateway.routes[0].filters[0]=RequestRateLimiter=capacity=10, refillTokens=10, refillDuration=60

---

Task 2 - Service Aggregation

Objective: Create a unified API endpoint in the Gateway that fetches data from both ProductService and InventoryService and then aggregates the responses.

1. Using Zuul:

   Zuul doesn’t inherently support aggregation, so you need to manually combine data.

   a. Create an API endpoint /aggregate-data.

   b. Within this endpoint, make parallel calls to both ProductService and InventoryService.

   c. Combine the responses and send it back to the client.

2. Using Spring Cloud Gateway:

   a. Define a new route with a custom URI:

   spring.cloud.gateway.routes[2].id=aggregated-route
   spring.cloud.gateway.routes[2].uri=http://localhost:9999/aggregated-data

   b. In the handler, make WebFlux calls to both services and aggregate using zip or merge.

---

Task 3 - Custom Filters

Objective: Log details of incoming requests before forwarding.

1. Zuul Custom Filter:

   a. Create a class extending ZuulFilter.

   b. Override methods and in run() method, log the required details.

   c. Register this filter as a bean.

2. Spring Cloud Gateway Custom Filter:

   a. Implement GlobalFilter interface.

   b. Override the filter method to log details.

   c. Register as a bean.

---

Task 4 - Error Handling & Fallback

Objective: Provide a default response if a service is down.

1. Zuul Fallback:

   a. Implement FallbackProvider.

   b. Return a ClientHttpResponse from the fallbackResponse method.

2. Spring Cloud Gateway Fallback:

   a. Add a SetStatus filter to the route.

   b. Configure it to check the status of the downstream service.

   c. If the service is down, set an appropriate fallback response.

---

Task 5 - Drawbacks & Limitations

Objective: Implement unified authentication at the gateway level while keeping authorization at the microservice level. Understand the challenges.

1. Unified Authentication:

   a. Implement an authentication mechanism in the gateway (like JWT token verification).

   b. Once authenticated, forward the request to the microservice.

2. Service-level Authorization:

   a. In each microservice, check for the presence of certain roles or permissions before processing the request.

3. Challenges:

   • Complexity: With this setup, the system can become quite complex, as you're mixing concerns.
   • Debugging: If there's an authorization issue, identifying whether the problem lies in the gateway or the microservice can be challenging.
   • Maintenance: Updates related to security need to be done in multiple places.

---

Wrap Up:

Spring Cloud Gateway and Netflix Zuul bring a plethora of benefits to the table. They act as a perfect proxy layer in front of your microservices, providing features like routing, load balancing, and security out of the box. When implemented correctly, they can abstract away many complexities and provide a unified front to consumers, both internal and third-party.

However, as with all tools, they come with their own challenges and learning curves. Proper design considerations are essential to avoid creating a monolithic gateway that becomes a bottleneck or a single point of failure.

[Rajashree-Ravi]

@akash-coded

Please find the proxy implementation part-1

-- Edited --
Updated order service entities

ecommerce-microservice-in-proxy-pattern-part-1.zip

[arghyagiri]

@akash-coded :
Part-1 : https://github.com/arghyagiri/microservice-e2/tree/main/e-commerce-microservices-zuul-proxy/Part-1
Part-2 : https://github.com/arghyagiri/microservice-e2/tree/main/e-commerce-microservices-zuul-proxy/Part-2

[jay4tech]

Hi @akash-coded

Part 1 -
https://github.com/jay4tech/order-service/tree/msa_167_part_1
https://github.com/jay4tech/inventory-service
https://github.com/jay4tech/product-service/tree/msa_167_part_1

[jay4tech]

Hi @akash-coded
Name: Jay Prakash Kumar

Part 2 -

https://github.com/jay4tech/product-service/tree/msa_167_part_2
https://github.com/jay4tech/order-service/tree/msa_167_part_2
https://github.com/jay4tech/inventory-service/tree/msa_167_part_2
https://github.com/jay4tech/api-gateway/tree/msa_167_part_2

[AnuragMishra58]

Hi @akash-coded
PFA zip for proxy and zuul api gatway tasks with postman test collection
Zuul-API-Gateway-Proxy-Task.zip

[shriramram]

Hi @akash-coded
Name - Dattatraya Shriram
Description - Implementation of proxy and zuul api gatway tasks (Part-2 is partially completed.)
microservices-proxy-part-1.zip
microservices-proxy-part-2.zip

[Rajashree-Ravi]

@akash-coded

Please find the proxy pattern implementation part-2

ecommerce-microservice-in-proxy-pattern-part-2.zip