Service Discovery: Eureka vs Kubernetes

//RegistryApp.java
package com.javabrahman.cloud.discovery.registry;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class RegistryApp {

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

spring.application.name=registry
server.port=8761
# a single registry: it does not register with, or fetch from, another one
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

# for this demonstration only - react within seconds instead of minutes
eureka.server.enable-self-preservation=false
eureka.server.eviction-interval-timer-in-ms=1000
eureka.server.response-cache-update-interval-ms=1000

//CatalogApp.java
package com.javabrahman.cloud.discovery.catalog;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class CatalogApp {

  record Book(String isbn, String title, int price, String servedBy) {}

  @Value("${server.port}")
  private int port;

  @GetMapping("/books/{isbn}")
  Book book(@PathVariable String isbn) {
    return new Book(isbn, "Effective Java", 450, "catalog-service on port " + port);
  }

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

spring.application.name=catalog-service
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.instance.hostname=localhost

# for this demonstration only - heartbeat every second, expire after 3 seconds (defaults: 30 and 90)
eureka.instance.lease-renewal-interval-in-seconds=1
eureka.instance.lease-expiration-duration-in-seconds=3

//OrderApp.java
package com.javabrahman.cloud.discovery.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestClient;

@SpringBootApplication
public class OrderApp {

  @Bean(defaultCandidate = false)
  @LoadBalanced
  RestClient.Builder loadBalancedBuilder() {
    return RestClient.builder();
  }

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

//OrderController.java
package com.javabrahman.cloud.discovery.order;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestClient;

@RestController
public class OrderController {

  record OrderRequest(String isbn, int quantity) {}
  record Book(String isbn, String title, int price, String servedBy) {}
  record Order(String title, int quantity, int total, String priceFrom) {}

  private final RestClient catalog;
  private final DiscoveryClient discovery;

  OrderController(@LoadBalanced RestClient.Builder builder, DiscoveryClient discovery) {
    this.catalog = builder.baseUrl("http://catalog-service").build();
    this.discovery = discovery;
  }

  @PostMapping("/orders")
  Order place(@RequestBody OrderRequest request) {
    Book book = catalog.get().uri("/books/{isbn}", request.isbn()).retrieve().body(Book.class);
    return new Order(book.title(), request.quantity(), book.price() * request.quantity(), book.servedBy());
  }

  // what this service currently knows about the catalog service
  @GetMapping("/instances")
  Map<String, Object> instances() {
    List<String> uris = discovery.getInstances("catalog-service").stream()
        .map(instance -> instance.getUri().toString()).sorted().toList();
    Map<String, Object> result = new LinkedHashMap<>();
    result.put("count", uris.size());
    result.put("instances", uris);
    return result;
  }
}

spring.application.name=order-service
server.port=8080
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.instance.hostname=localhost

# for this demonstration only - refresh the local copy of the registry every second (defaults: 30 and 35 seconds)
eureka.client.registry-fetch-interval-seconds=1
spring.cloud.loadbalancer.cache.ttl=1s

apiVersion: apps/v1
kind: Deployment
metadata:
  name: catalog-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: catalog-service
  template:
    metadata:
      labels:
        app: catalog-service
    spec:
      containers:
        - name: catalog-service
          image: example/catalog-service:1.0
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: catalog-service
spec:
  selector:
    app: catalog-service
  ports:
    - port: 80
      targetPort: 8080