Understanding the API Gateway Design Pattern

-

 In the world of microservices, the API Gateway design pattern plays a crucial role in managing how clients communicate with your backend services. This article will break down what an API Gateway is, why you need one, and provide real-time examples that are easy to understand.

What is an API Gateway?

Why Use an API Gateway?

How Does an API Gateway Work?

Basic Example

Project Setup

Step 1: Creating the API Gateway

<dependencies>
    <!-- Spring Boot Web Dependency -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- Spring Boot Actuator for Health Checks -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- Eureka Client (Optional for Service Discovery) -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR12</version> <!-- Version of Spring Cloud -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Step 2: API Gateway Routing Configuration

server:
  port: 8080  # API Gateway runs on port 8080

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8081   # User service URL
          predicates:
            - Path=/user/**

        - id: order-service
          uri: http://localhost:8082   # Order service URL
          predicates:
            - Path=/order/**

        - id: product-service
          uri: http://localhost:8083   # Product service URL
          predicates:
            - Path=/product/**

Explanation:

Step 3: Setting up Microservices (Product, Order, User)

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

    <!-- Eureka Client (optional if using service discovery) -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>
@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/info")
    public String getUserInfo() {
        return "User Info: John Doe";
    }
}

Step 4: Running the Microservices

Step 5: Adding Extra Features to the API Gateway

1. Load Balancing

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user/**

2. Global Filters for Security and Logging

@Bean
public GlobalFilter customGlobalFilter() {

    return (exchange, chain) -> {
        System.out.println("Global Pre Filter executed");

        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            System.out.println("Global Post Filter executed");
        }));
    };
}

3. Rate Limiting

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8081
          predicates:
            - Path=/user/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

Real-Time Scenario

Without an API Gateway:

With an API Gateway:

Handling Different Scenarios with API Gateway

Conclusion

Comments

Post a Comment

Popular posts from this blog

Understanding Service Discovery in Microservices

-
Image
  In a microservices architecture, numerous services work together to form a seamless application. However, managing these services can become complex as the number of services increases. This is where   Service Discovery   comes into play. In this article, we’ll delve deeper into what Service Discovery is, its importance, how it functions, and real-world examples to illustrate its benefits. What is Service Discovery? Service Discovery  is a mechanism that allows services to automatically find and communicate with each other in a microservices architecture. Instead of hardcoding the addresses of other services, Service Discovery enables services to dynamically locate each other, which is especially beneficial in cloud-based environments where services may frequently scale up or down. Key Concepts Service Registry : A database of available service instances, where each service registers itself and its current location (e.g., IP address and port). Popular service regis...
Read more

Understanding Executors and ExecutorService in Java

-
Image
  When writing Java applications, there are times when you want to run multiple tasks in parallel, such as downloading files, processing data, or making API calls. Instead of creating new threads manually for each task, Java provides a simpler and more efficient way through  Executors   and   ExecutorService . Photo by  Mohammad Rahmani  on  Unsplash 1. What is an Executor? The  Executor  interface is a simple way to run tasks in the background. Instead of dealing with thread creation, you pass the task (in the form of a  Runnable  object) to the  Executor , and it handles the execution. Let’s start with a very basic example to understand this: import java.util.concurrent.Executor; import java.util.concurrent.Executors; public class SimpleExecutorExample { public static void main (String[] args) { // Create an Executor using the Executors factory method Executor executor = Executors.newSi...
Read more

HashMap Internal Implementation in Java

-
Image
  Java’s   HashMap  is one of the most commonly used data structures, providing an efficient way to store and retrieve data. In this post, we will explore the internals of HashMap, how it works, the significance of methods like   hashCode()   and   equals(),   and what happens when we override or don't override them. What is a HashMap? A  HashMap  in Java is a part of the  Java Collections Framework , used for storing key-value pairs. It is an implementation of the  Map interface , which means it provides methods to add, remove, and retrieve elements based on keys. Interfaces Implemented by HashMap Map<K,V> : The core interface for key-value mapping. Clonable : Allows cloning of  HashMap  objects. Serializable : Enables HashMap objects to be serialized, meaning they can be converted into a byte stream and saved to a file. So, in short,  HashMap  is a part of the Java Collections Framework and implements sev...
Read more

Understanding “try-with-resources” in Java

-
Image
  Java’s   try-with-resources   is a feature introduced in   Java 7   that simplifies the way we handle resources (like files, database connections, etc.) while ensuring they are closed properly, even if an exception occurs. It’s a powerful tool, but many developers struggle with explaining or using it correctly in interviews. This article will break it down into easy-to-understand concepts and examples. What is  try-with-resources ? In Java, resources like file streams, database connections, or sockets need to be manually closed after use to avoid memory leaks. Before  Java 7 , we had to write code to close these resources in the  finally  block of a  try-catch  structure. The  try-with-resources  feature simplifies this by automatically closing resources for you. This happens as long as the resource implements the  AutoCloseable  interface, which means any object that can be closed (like file streams or databas...
Read more