Service Discovery & Load Balancing

Microservices are independent and dynamic—instances can scale up/down, restart, or move across hosts. To enable communication without hardcoding URLs, service discovery and load balancing are essential for scalable, resilient, cloud-native architectures.

Service Discovery (Eureka)

Service discovery allows microservices to register themselves and discover other services dynamically at runtime, without relying on hardcoded URLs.

Key Components:

Workflow:

1. Microservice A starts → registers itself with Eureka Server.
2. Microservice B wants to call A → queries Eureka Server → retrieves available instances.
3. Service B calls one of the instances dynamically using the URL provided by Eureka.
4. Heartbeat mechanism: registered services periodically send signals to stay alive in the registry.

Spring Boot Setup Example:

Eureka Server:

@SpringBootApplication
@EnableEurekaServer
publicclassEurekaServerApplication {
publicstaticvoidmain(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

application.yml (Server):

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

Eureka Client (Service A / Payment Service):

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

application.yml (Client):

spring:
  application:
    name: payment-service

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

Benefits of Eureka:

• Dynamic service registration/discovery
• Decouples service URLs from clients
• Essential for cloud-native microservices
• Easy integration with Spring Cloud ecosystem

Client-Side Load Balancing (Spring Cloud LoadBalancer)

Even with service discovery, multiple instances of a service may exist. Load balancing ensures requests are distributed among available instances for high availability and fault tolerance.

Distributes client requests across multiple service instances dynamically.

Key Features:

• Client-side load balancing
• Integrates seamlessly with Eureka
• Supports multiple algorithms: Round Robin, Random, Weighted

Workflow:

1. Service A queries Eureka → gets list of Service B instances.
2. LoadBalancer picks one instance (e.g., Round Robin).
3. Request is sent to the selected instance.

Spring Boot Example (WebClient + LoadBalancer):

@Bean
@WebClientLoadBalanced
public WebClient webClient(WebClient.Builder builder) {
    return builder.build();
}

// Using WebClient
@Autowired
private WebClient.Builder webClientBuilder;

public Mono<PaymentResponse> callPaymentService(PaymentRequest request) {
    return webClientBuilder.build()
            .post()
            .uri("<http://payment-service/payments>") // logical service name
            .bodyValue(request)
            .retrieve()
            .bodyToMono(PaymentResponse.class);
}

Feign Client + LoadBalancer Example:

@FeignClient(name = "payment-service")
public interface PaymentClient {

    @PostMapping("/payments")
    PaymentResponse pay(@RequestBody PaymentRequest request);
}

Benefits:

• Distributes load automatically across service instances
• Avoids downtime when an instance fails
• Works seamlessly with Eureka for dynamic instance discovery

High-Level Architecture

             +----------------+
             | EurekaServer  |
             +----------------+
               ^           ^
               |           |
     +---------+           +---------+
     |                           |
+---------+                 +---------+
| Service A |  <--LoadBalancer-->  | Service B |
+---------+                 +---------+

Flow:

1. Service A queries Eureka to discover Service B instances.
2. Spring Cloud LoadBalancer selects a healthy instance.
3. Request is routed → response returned.

Workflow:

Client → LoadBalancer → Eureka → Service Instance → Response

• Eureka: tells the client where services are
• LoadBalancer: picks the best instance
• Client: makes the request without hardcoding URLs

Best Practices

• Always use @LoadBalanced with WebClient, RestTemplate, or Feign when calling other services.
• Combine with Resilience4j (Circuit Breaker, Retry, Rate Limiter) for fault tolerance.
• Enable health checks to automatically remove unhealthy instances.
• Use Eureka Dashboard to monitor service health and registry.
• Prefer client-side load balancing for low latency; server-side load balancing (Nginx, API Gateway) for centralized control.

Difference between Edreka and Spring Cloud LoadBalancer

Conclusion

• Eureka → Service registry & discovery → dynamic service locations
• Spring Cloud LoadBalancer → Client-side load distribution → high availability
• Together, they enable scalable, resilient, and loosely-coupled microservices.