Guided Exercise - Microservices - Design Patterns - API Gateway

[akash-coded]

API Gateway Pattern in Spring Microservices

The API Gateway pattern is another crucial pattern in microservices architecture, serving as a single-entry point for various microservices running in your ecosystem. It is responsible for request routing, load balancing, security, and other cross-cutting concerns.

Prerequisites

• JDK 8 or higher
• Maven
• IDE like IntelliJ IDEA or Eclipse
• Docker (optional but recommended)

Architecture Overview

• CustomerService: Manages customer data
• OrderService: Manages orders
• ApiGateway: A single entry point that routes requests to various services

Step 1: Create Microservices

Create three Spring Boot projects (CustomerService, OrderService, ApiGateway).

Step 2: Add Dependencies

• For CustomerService and OrderService, add:

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

• For ApiGateway, add:

<!-- Spring Cloud Gateway -->
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- Spring Cloud Netflix Eureka Client -->
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Step 3: Create Business Logic

CustomerService:

@RestController
@RequestMapping("/customers")
public class CustomerController {
  @GetMapping("/{id}")
  public Customer getCustomer(@PathVariable Long id) {
    return new Customer(id, "John");
  }
  // ...
}

OrderService:

@RestController
@RequestMapping("/orders")
public class OrderController {
  @GetMapping("/{id}")
  public Order getOrder(@PathVariable Long id) {
    return new Order(id, "Laptop");
  }
  // ...
}

Step 4: Implement API Gateway

In the ApiGateway application, you'll need to define routes for your services. Modify your application.yml or application.properties to add the following:

spring:
  cloud:
    gateway:
      routes:
        - id: customer_route
          uri: http://localhost:8081 # Target service URL
          predicates:
            - Path=/customers/** # Incoming URL pattern
        - id: order_route
          uri: http://localhost:8082 # Target service URL
          predicates:
            - Path=/orders/** # Incoming URL pattern

Step 5: Service Discovery (Optional)

If you're using Eureka or other service discovery, the routes could be more dynamic. Add the following to your ApiGateway's application.properties:

eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

Code Repository Structure

• CustomerService
  • src
    • main
      • java
        • controller
          • CustomerController.java
        • model
          • Customer.java
• OrderService
  • src
    • main
      • java
        • controller
          • OrderController.java
        • model
          • Order.java
• ApiGateway
  • src
    • main
      • java
        • ApiGatewayApplication.java

Internal Details

• Request Routing: API Gateway efficiently routes requests to appropriate services.
• Load Balancing: With service discovery, the API Gateway can perform load balancing.
• Caching: Implement caching strategies to minimize network calls.
• Security: Centralize authentication/authorization.

Best Practices, Dos, and Don'ts

1. Rate Limiting: Implement rate limiting on your API Gateway.
2. Monitoring: Add centralized logging and monitoring.
3. Caching: Cache frequent API calls at the gateway level.
4. Authentication and Authorization: Implement these at the gateway level.
5. Resilience: Add a Circuit Breaker pattern for fault tolerance.
6. Versioning: Keep your gateway updated with your microservices API versions.
7. Testing: Add comprehensive testing for the API Gateway.

Optimizations

1. Response Aggregation: You can combine multiple service responses into one at the API Gateway.
2. Throttling: You can throttle the incoming requests based on IPs or user-IDs.
3. Compression: Use compression algorithms to reduce the payload sizes for optimization.

The API Gateway pattern is highly useful for operations, security, and optimizing requests and should be part of your microservices architecture for more resilient systems.

---

Let's take a deeper dive into the microservices, their responsibilities, and differences.

Deeper Dive into Microservices

CustomerService

Responsibilities

• CRUD operations for Customer
• Provide additional services like customer lookup by various fields

Configuration & Setup

1. Create a Spring Boot project with Web, JPA, and H2 dependencies.
2. Add model, repository, and controller classes.

Code Snippet & Hints

Model:

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}

Repository:

public interface CustomerRepository extends JpaRepository<Customer, Long> {}

Controller:

@RestController
@RequestMapping("/customers")
public class CustomerController {
    
    @Autowired
    private CustomerRepository repository;

    @GetMapping("/{id}")
    public Customer getCustomer(@PathVariable Long id) {
        return repository.findById(id).orElse(null);
    }
    // Additional CRUD methods
}

Differences & Unique Features

• Manages customer-specific data.
• Potentially, can implement customer-specific logic like credit scoring.

---

OrderService

Responsibilities

• CRUD operations for Orders
• Handle order status updates

Configuration & Setup

1. Create another Spring Boot project with Web, JPA, and H2 dependencies.
2. Again, model, repository, and controller are needed.

Code Snippet & Hints

Model:

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String product;
    private Long customerId;
    // getters and setters
}

Repository:

public interface OrderRepository extends JpaRepository<Order, Long> {}

Controller:

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

    @Autowired
    private OrderRepository repository;

    @GetMapping("/{id}")
    public Order getOrder(@PathVariable Long id) {
        return repository.findById(id).orElse(null);
    }
    // Additional CRUD methods
}

Differences & Unique Features

• Manages order-specific data.
• Can handle more advanced features like order tracking.

---

ApiGateway

Responsibilities

• Route requests to appropriate services
• Security, Logging, and other cross-cutting concerns

Configuration & Setup

1. Spring Boot project with Gateway and Eureka client dependencies.
2. Configure application.yml for routing.

Code Snippet & Hints

spring:
  cloud:
    gateway:
      routes:
      - id: customer_route
        uri: http://localhost:8081
        predicates:
          - Path=/customers/**
      - id: order_route
        uri: http://localhost:8082
        predicates:
          - Path=/orders/**

Differences & Unique Features

• Does not manage business data.
• Handles only routing, security, and other cross-cutting concerns.

Best Practices for Deep Dive

1. Security: Always secure your microservices. Even if the API Gateway handles external requests securely, internal security is crucial.
2. Database per Service: Keep separate databases for each service to ensure loose coupling.
3. API Composition: ApiGateway can perform data composition from multiple services if needed.
4. Testing: Implement unit tests, integration tests, and end-to-end tests for each service.

By examining each microservice in detail, you can see how they each serve unique responsibilities. However, they are also similar in structure since they're all Spring Boot applications. This setup fosters consistency and maintainability, which is crucial in a microservices architecture.

[AnuragMishra58]

Hi @akash-coded
Please find the assignment for API Gateway routing using service discovery to customer and order.
Name: Anurag Mishra
Emp Id: 550966
api-gateway-using-service-discovery.zip

[HarshDPandya]

Hi Akash, Sharing my code in zip file for Microservices - Design Patterns - API Gateway with Eureka service discovery.
Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-api-gateway-eurekaserver-HarshPandya-2066481.zip

[Prasadpoojary]

Hi Akash,

API Gateway with Eureka service discovery
Name : Prasad

API-Gateway with Eureka.zip

Thanks

[arghyagiri]

@akash-coded : https://github.com/arghyagiri/microservice-e2/tree/main/library-management-system-modularized

[jay4tech]

Hi @akash-coded
Name: Jay Prakash Kumar

Here are solutions, without discovery as you told us to complete -

https://github.com/jay4tech/order-service/tree/msa_157
https://github.com/jay4tech/customer-service/tree/msa_157
https://github.com/jay4tech/api-gateway/tree/msa_157

Swagger UI -
http://localhost:8081/swagger-ui/index.html
http://localhost:8082/swagger-ui/index.html

All the requests are getting routed through the API gateway URL i.e. http://localhost:8080/<service_predicates>/

[Rajashree-Ravi]

Hi @akash-coded

I have implemented API discovery and API gateway on the library-microservices

https://github.com/Rajashree-Ravi/author-service
https://github.com/Rajashree-Ravi/borrowing-service
https://github.com/Rajashree-Ravi/book-service

https://github.com/Rajashree-Ravi/library-api-discovery
https://github.com/Rajashree-Ravi/library-api-gateway

Library-Microservices.postman_collection.zip

[akash-coded]

@Rajashree-Ravi The library-api-gateway repo is empty.

[AnubhavG1999]

Hey Akash, here's my work towards the ApiGateway/Eureka task assigned during class.

Name: Anubhav Ghosh
Org: TCS
Emp ID: 2286865
Class: 11:00AM CST

EurekaApiGateway.zip

[AnubhavG1999]

EurekaApiGatewayII.zip

Had messed up ports in the application.properties for the EurekaServer/ApiGateway

[samik2023]

Hi Akash,

Here are the urls and codebase:

https://github.com/samik2023/order-service
https://github.com/samik2023/customer-service
https://github.com/samik2023/gateway-service

Gateway:
http://localhost:9000/api/orders
http://localhost:9000/api/customers

Services:
http://localhost:8082/api/orders
http://localhost:8085/api/customers

Regards
Samik

[ssagarwala]

Hello @akash-coded ,

good morning,

Please check this https://github.com/ssagarwala/API-Gateway-practice

I also put in 2 screen shots.

Please provide feedback.
thanks and regards,
-Fatima.

[arulsudarvizhi1]

Hi @akash-coded ,
Please find attached the code for gateway microservice implementation.

1. customer service - http://localhost:8081/customer
2. order service - http://localhost:8082/order
3. gateway service -

http://localhost:8090/order [Order API accessed through gateway port]
http://localhost:8090/customer [Customer API accessed through gateway port]

three projects attached. Code worked to access API of customer and order through the port configured in gateway service

application gateway.zip

Name: Arul
Batch: Nov 7th to Dec 6th 7.30 AM batch

[bijumedayil]

Hi @akash-coded

Gateway Project ,Order and Customer Route
gateway-order-customer.zip

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Microservices - Design Patterns - API Gateway with Eureka service discovery.
Name: Harsh Pandya
microservice-api-gateway-eurekaserver-HarshPandya-2066481.zip

[obulix]

Hi @akash-coded. Please find my git hub link for my project.
Name : Dinakaran

https://github.com/obulix/MicSrv-ApiGateway

I have added postman link as well in the repository.
Please validate and let me know.

[pradnyakinge]

hi @akash-coded ,
Please find the below link of Microservices - Design Patterns - API Gateway with Eureka service discovery Exercise .
https://github.com/pradnyakinge/SpringBoot-Microservices/tree/main/ApiGatewayWithFeignAndErrorHandling

name : Pradnya Kinge
tcs emp id: 1052359

[jyothi241868]

Hi Akash,

Please find the attached file for API Gateway implementation.

Thanks,
Jyothi K

API Gateway.zip

[Abhrajit-7]

Hi Akash,

Please find the attached file for API Gateway implementation with Eureka service discovery.

Gateway Exercise.zip

Name: Abhrajit
Class: 7:30 AM (7th Nov Batch)

[raghavan-tcs]

Hi @akash-coded

Please find attached api-gateway implementation for library management system microservice. The postman collection

is also included where Get All Authors, Books and Borrowings were tested for verifying api gateway functionality.

mid-assessment_api_gateway.zip

Thanks
Raghavan S
Apr-17 -2024 Batch

[Aditi-12092024]

Hi Akash,
Please find attached api-gateway implementation.

API Gateway Impl.zip

Thanks
Aditi Sharma

[venom-xd]

Hi Akash,
Please find attached api-gateway implementation.

API-Gateway.zip

Thanks
Aditya Kumar