Giới thiệu Spring Cloud và Service Discovery

01-service-discovery/
  pom.xml                       parent Boot 4.0.8, BOM Spring Cloud 2025.1.3, Eureka server và client, LoadBalancer
  src/main/java/dev/canhdominich/cloud/
    registry/RegistryApplication.java    @EnableEurekaServer: sổ đăng ký
    catalog/CatalogApplication.java      dịch vụ được tra cứu, tự đăng ký
    catalog/CatalogController.java       GET /whoami trả về instance-id của bản đang chạy
    shop/ShopApplication.java            hai RestClient.Builder: một thường (@Primary) và một @LoadBalanced
    shop/ShopController.java             GET /call gọi http://catalog/whoami, GET /instances đếm bản thấy được
    DiscoveryDemo.java                   mở ba loại tiến trình, đo từng tình huống
    SelfPreservationDemo.java            đo thời gian sổ đăng ký loại một bản đã sập khi bật và tắt self-preservation

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.0.8</version>
        <relativePath/>
    </parent>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>cloud-service-discovery</artifactId>
    <version>1.0.0</version>
    <name>Spring Cloud - Service Discovery voi Eureka</name>

    <properties>
        <java.version>17</java.version>
        <spring-cloud.version>2025.1.3</spring-cloud.version>
        <main.class>dev.canhdominich.cloud.DiscoveryDemo</main.class>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.cloud.registry;

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

@SpringBootApplication
@EnableEurekaServer
public class RegistryApplication {

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

package dev.canhdominich.cloud.catalog;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CatalogApplication {

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

package dev.canhdominich.cloud.catalog;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CatalogController {

    private final String instance;

    public CatalogController(@Value("${eureka.instance.instance-id}") String instance) {
        this.instance = instance;
    }

    @GetMapping("/whoami")
    public String whoami() {
        return instance;
    }
}

package dev.canhdominich.cloud.shop;

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.context.annotation.Primary;
import org.springframework.web.client.RestClient;

@SpringBootApplication
public class ShopApplication {

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

    @Bean
    @Primary
    public RestClient.Builder plainBuilder() {
        return RestClient.builder();
    }

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

package dev.canhdominich.cloud.shop;

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.RestController;
import org.springframework.web.client.RestClient;

@RestController
public class ShopController {

    private final RestClient catalog;
    private final DiscoveryClient discovery;

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

    @GetMapping("/call")
    public String call() {
        return catalog.get().uri("/whoami").retrieve().body(String.class);
    }

    @GetMapping("/instances")
    public String instances() {
        return String.valueOf(discovery.getInstances("catalog").size());
    }
}

package dev.canhdominich.cloud;

import dev.canhdominich.cloud.catalog.CatalogApplication;
import dev.canhdominich.cloud.registry.RegistryApplication;
import dev.canhdominich.cloud.shop.ShopApplication;
import java.io.File;
import java.net.ServerSocket;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BooleanSupplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DiscoveryDemo {

    private static final HttpClient HTTP = HttpClient.newHttpClient();

    public static void main(String[] args) throws Exception {
        run().forEach(System.out::println);
    }

    public static List<String> run() throws Exception {
        List<String> lines = new ArrayList<>();
        List<Node> nodes = new ArrayList<>();
        try {
            Node registry = launch(nodes, RegistryApplication.class, "registry",
                    "--eureka.client.register-with-eureka=false",
                    "--eureka.client.fetch-registry=false",
                    "--eureka.server.enable-self-preservation=false",
                    "--eureka.server.eviction-interval-timer-in-ms=1000",
                    "--eureka.server.response-cache-update-interval-ms=1000");
            String eureka = "http://localhost:" + registry.port + "/eureka/";
            lines.add("-- a registry with nothing registered");
            lines.add("catalog instances in the registry: " + instanceIds(registry.port));
            Node catalogA = launch(nodes, CatalogApplication.class, "catalog", catalogArgs(eureka, "catalog-A"));
            Node catalogB = launch(nodes, CatalogApplication.class, "catalog", catalogArgs(eureka, "catalog-B"));
            Node shop = launch(nodes, ShopApplication.class, "shop",
                    "--eureka.client.service-url.defaultZone=" + eureka,
                    "--eureka.client.register-with-eureka=false",
                    "--eureka.client.jersey.enabled=false",
                    "--eureka.client.registry-fetch-interval-seconds=1",
                    "--spring.cloud.loadbalancer.cache.ttl=1s");
            lines.add("-- two instances of one service register themselves");
            lines.add("shop sees 2 instances of catalog within 40 s: " + waitFor(() -> text(shop.port, "/instances").equals("2"), 40_000));
            lines.add("instances listed by the registry: " + instanceIds(registry.port));
            lines.add("-- the load balancer spreads calls");
            lines.add("20 calls to http://catalog/whoami: " + calls(shop.port, 20));
            lines.add("-- an instance leaves cleanly (SIGTERM)");
            catalogA.process.destroy();
            catalogA.process.waitFor();
            long start = System.currentTimeMillis();
            boolean gone = waitFor(() -> instanceIds(registry.port).equals("[catalog-B]"), 15_000);
            lines.add("registry lists only catalog-B within 15 s: " + gone);
            lines.add("shop sees 1 instance within 15 s: " + waitFor(() -> text(shop.port, "/instances").equals("1"), 15_000));
            lines.add("10 calls afterwards: " + calls(shop.port, 10));
            lines.add("-- an instance that crashes (SIGKILL)");
            Node catalogC = launch(nodes, CatalogApplication.class, "catalog", catalogArgs(eureka, "catalog-C"));
            waitFor(() -> text(shop.port, "/instances").equals("2"), 40_000);
            catalogC.process.destroyForcibly();
            catalogC.process.waitFor();
            long killed = System.currentTimeMillis();
            int failed = 0;
            int total = 0;
            long firstGood = -1;
            long lastFail = -1;
            while (System.currentTimeMillis() - killed < 15_000) {
                total++;
                if (status(shop.port, "/call") == 200) {
                    if (firstGood < 0) {
                        firstGood = System.currentTimeMillis();
                    }
                } else {
                    failed++;
                    lastFail = System.currentTimeMillis();
                }
                Thread.sleep(100);
            }
            lines.add("some calls failed while the registry still listed the dead instance: " + (failed > 0));
            lines.add("failed calls: " + failed + " of " + total + ", last failure " + (lastFail < 0 ? 0 : (lastFail - killed) / 1000) + " s after the crash");
            lines.add("failures stopped by themselves within 10 s: " + (lastFail < 0 || lastFail - killed < 10_000));
            lines.add("registry lists only catalog-B at the end: " + instanceIds(registry.port));
        } finally {
            for (Node node : nodes) {
                node.process.destroyForcibly();
            }
        }
        return lines;
    }

    static String[] catalogArgs(String eureka, String id) {
        return new String[] {
            "--eureka.client.service-url.defaultZone=" + eureka,
            "--eureka.instance.instance-id=" + id,
            "--eureka.instance.lease-renewal-interval-in-seconds=1",
            "--eureka.instance.lease-expiration-duration-in-seconds=3",
            "--eureka.client.fetch-registry=false",
            "--eureka.client.jersey.enabled=false"
        };
    }

    static Map<String, Integer> calls(int shopPort, int count) {
        Map<String, Integer> counts = new TreeMap<>();
        for (int i = 0; i < count; i++) {
            counts.merge(text(shopPort, "/call"), 1, Integer::sum);
        }
        return counts;
    }

    static Node launch(List<Node> nodes, Class<?> main, String name, String... extra) throws Exception {
        int port = freePort();
        List<String> command = new ArrayList<>(List.of(
                System.getProperty("java.home") + "/bin/java",
                "-Xmx160m",
                "-classpath", System.getProperty("java.class.path"),
                main.getName(),
                "--server.port=" + port,
                "--spring.application.name=" + name,
                "--spring.main.banner-mode=off",
                "--logging.level.root=WARN"));
        if (name.equals("registry")) {
            command.add("--eureka.client.service-url.defaultZone=http://localhost:" + port + "/eureka/");
        }
        command.addAll(List.of(extra));
        File logs = new File("target/logs");
        logs.mkdirs();
        File log = new File(logs, name + "-" + port + ".log");
        Process process = new ProcessBuilder(command).redirectErrorStream(true).redirectOutput(log).start();
        Node node = new Node(process, port);
        nodes.add(node);
        if (!waitFor(() -> status(port, "/") > 0, 60_000)) {
            throw new IllegalStateException(name + " did not start, see " + log);
        }
        return node;
    }

    static int freePort() throws Exception {
        try (ServerSocket socket = new ServerSocket(0)) {
            return socket.getLocalPort();
        }
    }

    static boolean waitFor(BooleanSupplier condition, long millis) throws InterruptedException {
        long deadline = System.currentTimeMillis() + millis;
        while (System.currentTimeMillis() < deadline) {
            try {
                if (condition.getAsBoolean()) {
                    return true;
                }
            } catch (RuntimeException ignored) {
            }
            Thread.sleep(200);
        }
        return false;
    }

    static String instanceIds(int registryPort) {
        String body = get(registryPort, "/eureka/apps/CATALOG", "application/json");
        List<String> ids = new ArrayList<>();
        Matcher matcher = Pattern.compile("\"instanceId\"\\s*:\\s*\"([^\"]+)\"").matcher(body);
        while (matcher.find()) {
            ids.add(matcher.group(1));
        }
        Collections.sort(ids);
        return ids.toString();
    }

    static String get(int port, String path, String accept) {
        try {
            HttpResponse<String> response = HTTP.send(HttpRequest.newBuilder(URI.create("http://localhost:" + port + path)).header("Accept", accept).GET().build(), HttpResponse.BodyHandlers.ofString());
            return response.body();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }

    static String text(int port, String path) {
        return get(port, path, "text/plain");
    }

    static int status(int port, String path) {
        try {
            return HTTP.send(HttpRequest.newBuilder(URI.create("http://localhost:" + port + path)).GET().build(), HttpResponse.BodyHandlers.discarding()).statusCode();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }

    record Node(Process process, int port) {
    }
}

package dev.canhdominich.cloud;

import dev.canhdominich.cloud.DiscoveryDemo.Node;
import dev.canhdominich.cloud.catalog.CatalogApplication;
import dev.canhdominich.cloud.registry.RegistryApplication;
import java.util.ArrayList;
import java.util.List;

public class SelfPreservationDemo {

    public static void main(String[] args) throws Exception {
        System.out.println("self preservation false, crash 10 s after start: evicted after " + secondsUntilEvicted("false", 10) + " s");
        System.out.println("self preservation true, crash 10 s after start: evicted after " + secondsUntilEvicted("true", 10) + " s");
        System.out.println("self preservation true, crash 90 s after start: evicted after " + secondsUntilEvicted("true", 90) + " s");
    }

    static long secondsUntilEvicted(String selfPreservation, int crashAfterSeconds) throws Exception {
        List<Node> nodes = new ArrayList<>();
        try {
            Node registry = DiscoveryDemo.launch(nodes, RegistryApplication.class, "registry",
                    "--eureka.client.register-with-eureka=false",
                    "--eureka.client.fetch-registry=false",
                    "--eureka.server.enable-self-preservation=" + selfPreservation,
                    "--eureka.server.eviction-interval-timer-in-ms=1000",
                    "--eureka.server.response-cache-update-interval-ms=1000");
            long registryStarted = System.currentTimeMillis();
            String eureka = "http://localhost:" + registry.port() + "/eureka/";
            DiscoveryDemo.launch(nodes, CatalogApplication.class, "catalog", DiscoveryDemo.catalogArgs(eureka, "catalog-A"));
            Node b = DiscoveryDemo.launch(nodes, CatalogApplication.class, "catalog", DiscoveryDemo.catalogArgs(eureka, "catalog-B"));
            DiscoveryDemo.waitFor(() -> DiscoveryDemo.instanceIds(registry.port()).equals("[catalog-A, catalog-B]"), 30_000);
            Thread.sleep(Math.max(0, crashAfterSeconds * 1000L - (System.currentTimeMillis() - registryStarted)));
            b.process().destroyForcibly();
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() - start < 180_000) {
                if (DiscoveryDemo.instanceIds(registry.port()).equals("[catalog-A]")) {
                    return (System.currentTimeMillis() - start) / 1000;
                }
                Thread.sleep(1000);
            }
            return -1;
        } finally {
            for (Node node : nodes) {
                node.process().destroyForcibly();
            }
        }
    }
}

-- a registry with nothing registered
catalog instances in the registry: []
-- two instances of one service register themselves
shop sees 2 instances of catalog within 40 s: true
instances listed by the registry: [catalog-A, catalog-B]
-- the load balancer spreads calls
20 calls to http://catalog/whoami: {catalog-A=10, catalog-B=10}
-- an instance leaves cleanly (SIGTERM)
registry lists only catalog-B within 15 s: true
shop sees 1 instance within 15 s: true
10 calls afterwards: {catalog-B=10}
-- an instance that crashes (SIGKILL)
some calls failed while the registry still listed the dead instance: true
failed calls: 31 of 129, last failure 7 s after the crash
failures stopped by themselves within 10 s: true
registry lists only catalog-B at the end: [catalog-B]