Service Discovery & Load Balancing — Deep Dive

Problem:
  Service A needs to call Service B
  But Service B has 5 instances across 3 availability zones
  IPs change as pods restart
  How does A discover B's current IPs?

graph LR
    C["Client<br/>Order Service"] --> R["Registry<br/>Eureka/Consul"]
    R -->|"Payment service<br/>IPs: 10.0.1.5,<br/>10.0.2.3"| C
    C -->|"Calls 10.0.1.5:8080"| P["Payment Service<br/>Instance 1"]
    C -->|"Calls 10.0.2.3:8080"| P2["Payment Service<br/>Instance 2"]

# In Spring Boot application.yml
spring:
  application:
    name: order-service
  cloud:
    eureka:
      client:
        serviceUrl:
          defaultZone: http://eureka-server:8761/eureka/

// Order Service queries Eureka
@RestController
public class OrderController {

    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable String id) {
        // Get all Payment Service instances from Eureka
        List<ServiceInstance> instances = 
            discoveryClient.getInstances("payment-service");

        if (instances.isEmpty()) {
            throw new ServiceUnavailableException("payment-service");
        }

        // Client-side load balancing: pick instance 0
        ServiceInstance instance = instances.get(0);
        String url = instance.getUri() + "/api/payments/" + id;

        return restTemplate.getForObject(url, Order.class);
    }
}

graph LR
    C["Client<br/>Order Service"] --> LB["Load Balancer<br/>Virtual IP<br/>payment-service.default.svc"]
    LB --> R["Registry<br/>Kubernetes API"]
    R -->|"Payment pods:<br/>10.0.1.5, 10.0.2.3"| LB
    LB -->|"Distributes<br/>traffic"| P1["Payment Pod 1"]
    LB -->|"Distributes<br/>traffic"| P2["Payment Pod 2"]

// In Kubernetes, just use DNS name
// Kubernetes CoreDNS handles discovery + load balancing
@RestTemplate
public Order callPaymentService() {
    String url = "http://payment-service.default.svc.cluster.local:8080/api/payments";
    return restTemplate.getForObject(url, Order.class);
}

# consul-config.hcl
service {
  name = "payment-service"
  port = 8080
  check {
    http     = "http://localhost:8080/health"
    interval = "10s"
    timeout  = "5s"
  }
}

// Client fetches from Consul
public String discoverPaymentService() {
    Response<List<CatalogService>> response = 
        consul.getCatalogClient().getService("payment-service");

    List<CatalogService> instances = response.getValue();
    CatalogService instance = instances.get(0); // pick one
    return instance.getServiceAddress() + ":" + instance.getServicePort();
}

graph LR
    C["Client Pod"] --> SP["Sidecar Proxy<br/>(Envoy)"]
    SP --> R["Control Plane<br/>(Istiod)"]
    R -->|"Payment Service<br/>endpoints: 10.0.1.5,<br/>10.0.2.3"| SP
    SP -->|"Routes traffic<br/>via iptables"| P1["Payment Pod 1"]
    SP -->|"Routes traffic<br/>via iptables"| P2["Payment Pod 2"]

// App just calls the service name; sidecar handles discovery
public Order callPaymentService() {
    // Sidecar intercepts; resolves payment-service automatically
    return restTemplate.getForObject("http://payment-service:8080/api/payments", Order.class);
}

Scenario: 3 instances, requests arrive
Instance 1: 10 active requests, avg processing time 100ms
Instance 2: 5 active requests, avg processing time 100ms
Instance 3: 2 active requests, avg processing time 100ms

Round-Robin would send new request to Instance 1 (next in rotation)
→ Queues up; longer latency

Least Connections would send to Instance 3
→ Faster response

Registry polls: GET http://payment-service-pod:8080/health
Response: 200 OK { "status": "UP" }
If poll fails 3x in a row → deregister instance

Client calls payment-service:8080 → 500 error
Circuit breaker counts failure
After threshold → remove from load balancing rotation

apiVersion: v1
kind: Pod
metadata:
  name: payment-pod
spec:
  containers:
  - name: payment
    livenessProbe:  # Is app alive?
      httpGet:
        path: /health/live
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 10
    readinessProbe:  # Is app ready for traffic?
      httpGet:
        path: /health/ready
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5

@Configuration
public class LoadBalancerConfig {

    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
            .interceptors((request, body, execution) -> {
                // LoadBalancer intercepts; resolves service name via DiscoveryClient
                return execution.execute(request, body);
            })
            .build();
    }
}

@RestController
public class OrderController {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/orders")
    public List<Payment> getPayments() {
        // LoadBalancer resolves "payment-service" to actual IP
        return restTemplate.getForObject(
            "http://payment-service/api/payments",
            List.class
        );
    }
}