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:

Component	Role
Eureka Server	Central registry for all microservices. Maintains a list of available service instances.
Eureka Client	Each microservice registers with Eureka Server and queries it to find other services.

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

Feature	Eureka	Spring Cloud LoadBalancer
Purpose	Service registry	Distribute requests across instances
Works With	Any Spring Boot microservice	Works with service discovery (Eureka)
Type	Server-Client	Client-side load balancer
Key Benefit	Dynamic discovery	Scalability & fault tolerance

---

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.