Integrating Spring Boot Eureka Server with Zuul API Gateway: A Complete Guide

In the world of microservices, service discovery and routing are critical components. Eureka Server, a part of the Netflix OSS suite, provides service discovery capabilities, while Zuul API Gateway is used for dynamic routing, monitoring, resiliency, and security. Integrating these two can greatly enhance the resilience and scalability of your microservices architecture. In this blog post, we'll walk through the steps of integrating Spring Boot Eureka Server with Zuul API Gateway, complete with detailed explanations and code samples.

Prerequisites

Basic understanding of Spring Boot.
JDK 8 or later installed.
Maven or Gradle for project management.
Integrated Development Environment (IDE) like IntelliJ IDEA or Eclipse.

Step 1: Setting Up Eureka Server

First, we need to set up the Eureka Server, which will act as our service registry.

Create a Spring Boot project for the Eureka Server.
Add Eureka Server Dependency in your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

Enable Eureka Server by adding the @EnableEurekaServer annotation in your main application class:

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

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

Configure Eureka Server in application.yml:

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    wait-time-in-ms-when-sync-empty: 0

Step 2: Setting Up Eureka Clients

Next, we need to create microservices that will register with the Eureka Server.

Create a Spring Boot project for your microservices.
Add Eureka Client Dependency in your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Enable Eureka Client by adding the @EnableEurekaClient annotation in your main application class:

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

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

Configure Eureka Client in application.yml:

server:
  port: 8081

spring:
  application:
    name: microservice1

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

Repeat these steps for additional microservices, changing the server.port and spring.application.name values as needed.

Step 3: Setting Up Zuul API Gateway

Now, let's set up Zuul as the API Gateway to route requests to our microservices.

Create a Spring Boot project for the Zuul API Gateway.
Add Zuul and Eureka Client Dependencies in your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Enable Zuul Proxy by adding the @EnableZuulProxy annotation in your main application class:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

Configure Zuul and Eureka Client in application.yml:

server:
  port: 8080

spring:
  application:
    name: zuul-api-gateway

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

zuul:
  routes:
    microservice1:
      path: /microservice1/**
      serviceId: microservice1
    microservice2:
      path: /microservice2/**
      serviceId: microservice2

In this configuration, we define routes for our microservices with serviceId values corresponding to the names used in spring.application.name for each microservice.

Step 4: Testing the Setup

To verify that everything is working as expected, follow these steps:

Run the Eureka Server:

mvn spring-boot:run

Run each Eureka Client (microservices):

mvn spring-boot:run

Run the Zuul API Gateway:

mvn spring-boot:run

Access Eureka Dashboard:

Open a browser and navigate to http://localhost:8761. You should see all your services registered.

Access Microservices through Zuul:

http://localhost:8080/microservice1/endpoint
http://localhost:8080/microservice2/endpoint

Replace /endpoint with actual endpoints exposed by your microservices.

Conclusion

By integrating Spring Boot Eureka Server with Zuul API Gateway, you can achieve seamless service discovery and dynamic routing in your microservices architecture. This setup provides a robust and scalable solution for managing microservices, enhancing resilience, and simplifying service interactions.

I hope this detailed guide helps you get started with integrating Eureka and Zuul in your Spring Boot projects. Happy coding!

Feel free to reach out if you have any questions or need further assistance. If you liked this guide, stay tuned for more articles on microservices architecture and Spring Boot!

Spring Boot Eureka Server with Zuul API Gateway