A Beginner’s Guide to Service Discovery with Spring Cloud Eureka

4 min readAug 6, 2023

Introduction

As more organizations gravitate towards microservices architecture, service discovery has become an integral part of this setup. It offers a way to automatically detect services on a network, making it possible for microservices to locate and communicate with each other. Today, we’re going to explore Spring Cloud Eureka, a Netflix OSS component used for service discovery. This guide is for beginners, so we’ll start from scratch and aim for a simple and clear understanding of the concept.

What is Service Discovery?

In a microservices architecture, each microservice is a standalone application with specific business functionality. Since these microservices need to communicate with each other to function as a complete application, they need to know each other’s network locations. Service Discovery comes into play here, maintaining a record of these services’ locations, helping them find each other, and enabling communication.

What is Spring Cloud Eureka?

Spring Cloud Eureka, part of the Spring Cloud Netflix project, is a service registry that allows microservices to register themselves and discover other services. In essence, it acts like a phone directory for your microservices, providing a mechanism for service-to-service discovery and registration.

Setting Up Eureka Server

Let’s start with setting up a Eureka Server. First, you need to add the spring-cloud-starter-netflix-eureka-server dependency in your pom.xml:

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

Then, you need to enable the Eureka server in your Spring Boot application by adding the @EnableEurekaServer annotation in your main application class:

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

Lastly, in your application.properties file, you need to define the properties for Eureka Server:

server.port=8761
eureka.client.registerWithEureka=false
eureka.client.fetchRegistry=false

Here, server.port specifies the port where Eureka server will run. The next two properties are set to false because we don't want the server to behave as a client and try to register itself.

Registering Services with Eureka

Next, we’re going to register a simple microservice with our Eureka server. Similar to setting up the Eureka Server, we start by adding the spring-cloud-starter-netflix-eureka-client dependency to our pom.xml file:

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

We then enable the Eureka client in our main application class:

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

Lastly, in the application.properties file, we define the Eureka server's URL:

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

Now, when this service starts, it will register itself with the Eureka server.

Service Discovery

So far, we have registered our service with Eureka. Now let’s see how to discover services. We will use Spring’s RestTemplate and @LoadBalanced annotation:

@SpringBootApplication
@EnableEurekaClient
public class ExampleMicroserviceApplication {
    @LoadBalanced
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

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

@LoadBalanced will integrate Ribbon load balancer, another Netflix component. Now, to consume a service, instead of hardcoding the URL, we'll use the service's logical name:

String response = restTemplate.exchange("http://example-microservice/service-endpoint", HttpMethod.GET, null, String.class);

Eureka and Ribbon will together handle the rest, discovering the service and load balancing any requests.

Health Monitoring with Eureka

Another feature of Eureka is health monitoring. It keeps track of registered services and their availability. Services send heartbeats to let Eureka know they’re up and running. If Eureka doesn’t receive a heartbeat within a certain period, it will unregister the service.

Eureka server’s dashboard, accessible at http://localhost:8761, provides a visual interface showing all registered services and their details.

Conclusion

In this guide, we covered the basics of Service Discovery, explored Spring Cloud Eureka, and learned how to register and discover services using it. We also touched on Eureka’s health monitoring. As you delve deeper into microservices, understanding these concepts and effectively using tools like Spring Cloud Eureka will be critical in building resilient and efficient applications.

Remember, this is just the tip of the iceberg. You can configure and customize Eureka to better suit your needs, including setting up an Eureka server cluster for high availability, tweaking health monitoring settings, securing your Eureka server, and much more. The official Spring Cloud documentation is an excellent resource to explore these advanced topics. Happy coding!