Dynamic Routing and Service Discovery in API Gateway

API gateways are an integral part of a microservice architecture that act as a single point of entry for customers to interact with microservices. The API gateway efficiently processes incoming requests and distributes them to the appropriate microservices. Dynamic routing involves routing client requests to different microservices based on certain parameters such as the request URL, HTTP header, or request payload. The service discovery API gateway allows you to dynamically find instances of available microservices without having to hardcode their locations.

Spring Boot typically implements dynamic routing and service discovery using frameworks such as Spring Cloud Routing and Eureka.

Step-by-step Implementation of the Dynamic Routing and Service Discovery in API Gateway

Below are the steps to implement Dynamic Routing and Service Discovery in API Gateway.

Set up the Eureka-Server

Step 1: Create a Spring project using Spring Initializr and add the below dependencies:

Dependencies:

• Spring Web
• Eureka Server
• Spring Dev Tools
• Lombok

Below is the Folder Structure:

Step 2: Open the application.properties file and write the below dependencies.

spring.application.name=EurekaServerService
server.port=9099
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone =http://${eureka.instance.hostname}:${server.port}/eureka

Step 3: In the main class, add @EnableEurekaServer annotation to enable Eureka server functionality.

package org.example.eurekaserverservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerServiceApplication {

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

}

Step 4: After completing the project, run it as spring application and once it runs successfully, it will start at port 9099.

Create the User-service microservice

Step 1: Create a spring project using spring initializer. On creating the project, add the below dependencies.

Dependencies:

• Spring Web
• Eureka Server Client
• Spring Dev Tools
• Lombok

After creating the project, the folder structure will be like below:

Step 2: Open the application.properties file. Then put the below code for the server port and eureka client configuration.

spring.application.name=user-service
server.port=8086

eureka.instance.prefer-ip-address=true
eureka.client.fetch-registry=true
eureka.client.register-with-eureka=true
eureka.client.service-url.defaultZone= http://localhost:9099/eureka

Step 3: Create the UserController class.

Go to src > org.example.userservice > UserController and write the code.

package org.example.userservice;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/client")
        public String check() {
        return "Welcome to client";
        }
}

Step 4: Now,Open the main class and write the @EnableDiscoveryClient into it.

package org.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {

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

}

Step 5: After completing the spring project, it run as spring application once it runs successful then it starts at port 8086.

Create the API Dynamic Routing

Step 1: Create a spring project using spring initializer on creating the project add the below dependencies into the project.

Dependencies:

• Spring Web
• Eureka Server Client
• Spring Dev Tools
• Lombok
• Spring Cloud Routing

After creating the Spring project, the file structure looks like the image below.

Step 2: Open the application.properties file and rename it to application.yml. Then, add the following YAML code for configuring the server port, Eureka client, and API routing:

server:
  servlet:
    context-path: /
  port: 9056

spring:
  application:
    name: API-GATEWAY
  profiles:
    active:
      - default
  cloud:
    gateway:
      default-filters:
        - DedupeResponseHeader=Access-Control-Allow-Credentials Access-Control-Allow-Origin
      routes:
        - id: USER-SERVICE
          uri: lb://user-service
          predicates:
            - Path= /**
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "*"
            allowedMethods: "*"
            allowedHeaders: "*"


eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:9099/eureka
  instance:
    prefer-ip-address: true

Step 3: Open the main class and add the @EnableDiscoveryClient annotation to enable service discovery functionality.

package org.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class ApiGatewayApplication {

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

}

Step 4: Run the application

Once the Spring project is completed and successfully runs as a Spring application, it will start at port 9056.

Eureka Dashboard:

Dynamic Routing API

Get the User-service microservice API access through the API Gateway routing mechanism port of the application.

GET http://localhost:9056/client

Output:

This example project demonstrates how to the implement the dynamic routing and services discovery in the API Gateway of the Spring Boot using Spring Cloud Routing and Eureka. By following the above steps, we can create the scalable and resilient microservices architecture with the efficient request routing.