Service Discovery in Microservices: Eureka, Client-Side vs Server-Side, Kubernetes

UserService (172.18.0.5:8081) --register--> Service Registry
UserService (172.18.0.9:8081) --register--> user-service: [172.18.0.5:8081, 172.18.0.9:8081]

OrderService --"where is user-service?"--> Service Registry
OrderService <--[172.18.0.5, 172.18.0.9]-- Service Registry

OrderService --GET http://172.18.0.5:8081/api/users/1--> UserService

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

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

# application.yml
server:
  port: 8761

eureka:
  client:
    register-with-eureka: false     # a standalone server doesn't register with itself
    fetch-registry: false

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

# application.yml
spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

@Configuration
public class HttpClientConfig {

    @Bean
    @LoadBalanced
    RestClient.Builder loadBalancedRestClientBuilder() {
        return RestClient.builder();
    }
}

@Service
public class UserClient {

    private final RestClient restClient;

    public UserClient(RestClient.Builder loadBalancedBuilder) {
        this.restClient = loadBalancedBuilder.baseUrl("http://user-service").build();
    }

    public UserResponse findById(Long id) {
        return restClient.get()
            .uri("/api/users/{id}", id)
            .retrieve()
            .body(UserResponse.class);
    }
}

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info
  endpoint:
    health:
      show-details: when-authorized

eureka:
  client:
    healthcheck:
      enabled: true               # send Actuator health status to Eureka
  instance:
    lease-renewal-interval-in-seconds: 30        # heartbeat frequency (default 30)
    lease-expiration-duration-in-seconds: 90     # evict after this long without a heartbeat (default 90)

@Component
public class PaymentGatewayHealthIndicator implements HealthIndicator {

    private final PaymentGatewayClient client;

    public PaymentGatewayHealthIndicator(PaymentGatewayClient client) {
        this.client = client;
    }

    @Override
    public Health health() {
        try {
            client.ping();
            return Health.up().withDetail("payment-gateway", "reachable").build();
        } catch (Exception ex) {
            return Health.down().withDetail("payment-gateway", "unreachable").build();
        }
    }
}

# Faster feedback for local development only
eureka:
  server:
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 5000
  client:
    registry-fetch-interval-seconds: 5
  instance:
    lease-renewal-interval-in-seconds: 5
    lease-expiration-duration-in-seconds: 10

# Eureka server application.yml
eureka:
  server:
    enable-self-preservation: true          # default; keep on in production
    renewal-percent-threshold: 0.85         # default
    eviction-interval-timer-in-ms: 60000    # default

// Not annotated with @Configuration, so component scanning doesn't pick it up globally
public class RandomLoadBalancerConfig {

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            Environment env, LoadBalancerClientFactory factory) {
        String name = env.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(
            factory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

@Configuration
@LoadBalancerClient(name = "user-service", configuration = RandomLoadBalancerConfig.class)
public class LoadBalancerClientsConfig { }

# Kubernetes Service
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - port: 80
      targetPort: 8081

# Another service in the same namespace calls:
#   http://user-service/api/users/1

eureka:
  instance:
    prefer-ip-address: true
    # hostname: user-service          # alternative: an explicit resolvable name
    # ip-address: 10.0.0.5            # when the auto-detected IP isn't reachable
  client:
    service-url:
      defaultZone: http://eureka-server:8761/eureka/    # the Compose service name

# Client
eureka:
  client:
    service-url:
      defaultZone: http://${EUREKA_USER}:${EUREKA_PASSWORD}@eureka-server:8761/eureka/

// Server
@Configuration
@EnableWebSecurity
public class EurekaSecurityConfig {

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.ignoringRequestMatchers("/eureka/**"))
            .authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
            .httpBasic(Customizer.withDefaults())
            .build();
    }
}

# src/test/resources/application-test.yml
eureka:
  client:
    enabled: false
spring:
  cloud:
    discovery:
      enabled: false

// or on a single test class
@SpringBootTest(properties = "eureka.client.enabled=false")
class UserClientTest { }