Service Discovery with Eureka

Introduction

In the realm of microservices architecture, service discovery is a critical component that enables services to locate and communicate with each other. Netflix's Eureka is one of the most popular service discovery tools used in building resilient and scalable microservices systems.

Service discovery helps in managing dynamic environments where services are constantly being deployed, scaled, or updated. Eureka acts as a registry for all services, allowing them to register themselves and discover other services by querying the registry.

Concept

What is Service Discovery?

Service discovery is the process by which one service can locate another service within a network. In microservices architecture, where services are deployed independently and often scaled across multiple instances, traditional static configurations become impractical. Service discovery provides a dynamic way to manage these interactions.

Why Use Eureka?

• Centralized Registry: Eureka serves as a centralized registry that holds information about all the services in the network.
• Self-Registration: Services automatically register themselves with Eureka when they start up and deregister when they shut down.
• Load Balancing: Eureka can be used to distribute traffic across multiple instances of a service, improving availability and performance.

Examples

Setting Up Eureka Server

To use Eureka for service discovery, you first need to set up an Eureka server. Here’s how you can do it using Spring Boot.

1. Create a New Spring Boot Project: Use Spring Initializr (https://start.spring.io/) to create a new project with the following dependencies:

   • Spring Web
   • Eureka Server

2. Configure the Eureka Server:

   Add the following configuration in application.yml or application.properties.

1server:
2   port: 8761
3 
4 eureka:
5   client:
6     register-with-eureka: false
7     fetch-registry: false
8     service-url:
9       defaultZone: http://localhost:8761/eureka/

3. Enable Eureka Server:

   Create a main application class and annotate it with @EnableEurekaServer.

1import org.springframework.boot.SpringApplication;
2 import org.springframework.boot.autoconfigure.SpringBootApplication;
3 import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
4 
5 @SpringBootApplication
6 @EnableEurekaServer
7 public class EurekaServerApplication {
8     public static void main(String[] args) {
9         SpringApplication.run(EurekaServerApplication.class, args);
10     }
11 }

4. Run the Eureka Server:

   Start your Spring Boot application. You should be able to access the Eureka dashboard at http://localhost:8761.

Registering a Service with Eureka

Now that you have an Eureka server running, let’s register a service with it.

1. Create a New Spring Boot Project: Use Spring Initializr again to create another project with the following dependencies:

   • Spring Web
   • Eureka Client

2. Configure the Service:

   Add the following configuration in application.yml or application.properties.

1server:
2   port: 8081
3 
4 spring:
5   application:
6     name: my-service
7 
8 eureka:
9   client:
10     service-url:
11       defaultZone: http://localhost:8761/eureka/

3. Enable Eureka Client:

   Create a main application class and annotate it with @EnableEurekaClient.

1import org.springframework.boot.SpringApplication;
2 import org.springframework.boot.autoconfigure.SpringBootApplication;
3 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
4 
5 @SpringBootApplication
6 @EnableEurekaClient
7 public class MyServiceApplication {
8     public static void main(String[] args) {
9         SpringApplication.run(MyServiceApplication.class, args);
10     }
11 }

4. Run the Service:

   Start your Spring Boot application. You should see my-service registered in the Eureka dashboard.

Consuming a Service

To consume another service using Eureka, you can use Feign or RestTemplate to make HTTP requests.

1. Add Dependencies: Add the following dependencies to your pom.xml if you are using Maven:

1<dependency>
2     <groupId>org.springframework.cloud</groupId>
3     <artifactId>spring-cloud-starter-openfeign</artifactId>
4 </dependency>

2. Enable Feign Client:

   Annotate your main application class with @EnableFeignClients.

1import org.springframework.boot.SpringApplication;
2 import org.springframework.boot.autoconfigure.SpringBootApplication;
3 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
4 import org.springframework.cloud.openfeign.EnableFeignClients;
5 
6 @SpringBootApplication
7 @EnableEurekaClient
8 @EnableFeignClients
9 public class ConsumerServiceApplication {
10     public static void main(String[] args) {
11         SpringApplication.run(ConsumerServiceApplication.class, args);
12     }
13 }

3. Create a Feign Client:

   Define an interface for the service you want to consume.

1import org.springframework.cloud.openfeign.FeignClient;
2 import org.springframework.web.bind.annotation.GetMapping;
3 
4 @FeignClient(name = "my-service")
5 public interface MyServiceClient {
6     @GetMapping("/api/data")
7     String getData();
8 }

4. Use the Feign Client:

   Inject and use the MyServiceClient in your service.

1import org.springframework.beans.factory.annotation.Autowired;
2 import org.springframework.web.bind.annotation.GetMapping;
3 import org.springframework.web.bind.annotation.RestController;
4 
5 @RestController
6 public class MyController {
7 
8     private final MyServiceClient myServiceClient;
9 
10     @Autowired
11     public MyController(MyServiceClient myServiceClient) {
12         this.myServiceClient = myServiceClient;
13     }
14 
15     @GetMapping("/consume")
16     public String consume() {
17         return myServiceClient.getData();
18     }
19 }

What's Next?

After setting up service discovery with Eureka, you can explore more advanced topics such as API Gateway using Zuul. An API gateway acts as a single entry point for all clients, routing requests to the appropriate microservices and handling cross-cutting concerns like authentication, monitoring, and rate limiting.

Stay tuned for more tutorials on building robust microservices architectures with Spring Boot!