使用Spring Boot 3的Spring Cloud Kubernetes教程

在这篇文章中，你将学习如何用Spring Cloud Kubernetes和Spring Boot 3创建、测试和运行应用程序。

你将看到如何在Kubernetes环境中使用Skaffold、Testcontainers、Spring Boot Admin和Fabric8客户端等工具。

这篇文章的主要目的是向你介绍Spring Cloud Kubernetes项目的最新版本。

源码：GitHub repository

首先，让我们介绍一下这个Github资源库：

它包含五个应用程序。
有三个微服务（雇员服务、部门服务、组织服务）
通过REST客户端相互通信并连接到Mongo数据库。
还有用Spring Cloud Gateway项目创建的API网关（gateway-service）。
最后，admin-service目录包含用于监控所有其他应用程序的Spring Boot Admin应用程序。

你可以使用一个Skaffold命令轻松地从源代码中部署所有的应用程序。

如果你从版本库根目录运行以下命令，它将用Jib Maven插件构建镜像，并将所有应用部署到Kubernetes集群上：

$ skaffold run

另一方面，你可以进入特定的应用程序目录，只使用完全相同的命令来部署它。
每个应用所需的所有Kubernetes YAML清单都放在k8s目录中。
在项目根k8s目录下还有一个全局配置，例如Mongo部署。

它是如何工作的
在我们的示例架构中，我们将使用Spring Cloud Kubernetes Config来通过ConfigMap和Secret注入配置，并使用Spring Cloud Kubernetes Discovery与OpenFeign客户端进行服务间通信。

我们所有的应用程序都在同一个命名空间内运行，但我们也可以将它们部署在几个不同的命名空间内，并通过OpenFeign处理它们之间的通信。

在这种情况下，我们唯一要做的就是将 spring.cloud.kubernetes.discovery.all-namespaces 属性设置为 true。

在我们的服务前面，有一个API网关。
它是一个独立的应用，但我们也可以使用本地CRD集成将其安装在Kubernetes上。

在我们的案例中，这是一个标准的Spring Boot 3应用，只是包括并使用了Spring Cloud Gateway模块。它还使用Spring Cloud Kubernetes Discovery和Spring Cloud OpenFeign来定位和调用下游服务。

使用Spring Cloud Kubernetes配置
我将通过部门服务的例子来描述实施细节。它暴露了一些REST端点，但也调用了雇员服务所暴露的端点。

除了标准模块，我们还需要将Spring Cloud Kubernetes纳入Maven的依赖项。

这里，我们必须决定是使用Fabric8客户端还是Kubernetes Java客户端。
就我个人而言，我有使用Fabric8的经验，所以我将使用spring-cloud-starter-kubernetes-fabric8-all starter来包含配置和发现模块。

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-kubernetes-fabric8-all</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

如你所见，我们的应用程序正在连接到Mongo数据库。
让我们提供应用程序所需的连接细节和凭证。
在k8s目录中，你会发现configmap.yaml文件。它包含了Mongo的地址和数据库的名称。
这些属性被作为application.properties文件注入到pod中。
现在是最重要的事情。ConfigMap的名称必须与我们应用程序的名称相同。
Spring Boot的名称由spring.application.name属性表示。

kind: ConfigMap
apiVersion: v1
metadata:
  name: department
data:
  application.properties: |-
    spring.data.mongodb.host: mongodb
    spring.data.mongodb.database: admin
    spring.data.mongodb.authentication-database: admin

在目前的情况下，应用程序的名称是department。这里是应用程序里面的application.yml文件：

spring:
  application:
    name: department

同样的命名规则也适用于Secret。我们在下面的Secret里面保存敏感数据，比如Mongo数据库的用户名和密码。你也可以在k8s目录下的secret.yaml文件内找到这些内容。

kind: Secret
apiVersion: v1
metadata:
  name: department
data:
  spring.data.mongodb.password: UGlvdF8xMjM=
  spring.data.mongodb.username: cGlvdHI=
type: Opaque

现在，让我们继续讨论部署清单。我们稍后将在这里澄清前两点。

Spring Cloud Kubernetes需要在Kubernetes上有特殊的权限，以便与主API互动
（1）我们不必为镜像提供一个标签--Skaffold会处理它
（2）为了启用从ConfigMap加载属性，我们需要设置spring.config.import=kubernetes: 属性（一种新方法）或将spring.cloud.bootstrap.enabled属性设置为true（旧方法）。
（3）我们将不直接使用属性，而是在部署上设置相应的环境变量。
（4）默认情况下，由于安全原因，通过API消耗secrets的功能没有被启用。为了启用它，我们将把SPRING_CLOUD_KUBERNETES_SECRETS_ENABLEAPI环境变量设置为true。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: department
  labels:
    app: department
spec:
  replicas: 1
  selector:
    matchLabels:
      app: department
  template:
    metadata:
      labels:
        app: department
    spec:
      serviceAccountName: spring-cloud-kubernetes # (1)
      containers:
      - name: department
        image: piomin/department # (2)
        ports:
        - containerPort: 8080
        env:
          - name: SPRING_CLOUD_BOOTSTRAP_ENABLED # (3)
            value: "true"
          - name: SPRING_CLOUD_KUBERNETES_SECRETS_ENABLEAPI # (4)
            value: "true"

使用Spring Cloud Kubernetes Discovery
我们已经在上一节使用spring-cloud-starter-kubernetes-fabric8-all starter包含了Spring Cloud Kubernetes Discovery模块。为了提供一个声明式REST客户端，我们还将包括Spring Cloud OpenFeign模块：

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

现在，我们可以声明@FeignClient接口。这里重要的是一个被发现的服务的名称。它应该与为雇员服务应用程序定义的Kubernetes服务的名称相同。

@FeignClient(name = "employee")
public interface EmployeeClient {

    @GetMapping("/department/{departmentId}")
    List<Employee> findByDepartment(@PathVariable("departmentId") String departmentId);

    @GetMapping("/department-with-delay/{departmentId}")
    List<Employee> findByDepartmentWithDelay(@PathVariable("departmentId") String departmentId);
}

下面是雇员服务应用的Kubernetes服务清单。该服务的名称是employee (1)。标签spring-boot是为Spring Boot Admin发现目的而设置的(2)。你可以在employee-service/k8s目录中找到以下YAML。

apiVersion: v1
kind: Service
metadata:
  name: employee # (1)
  labels:
    app: employee
    spring-boot: "true" # (2)
spec:
  ports:
    - port: 8080
      protocol: TCP
  selector:
    app: employee
  type: ClusterIP

只是为了澄清--这里是由OpenFeign客户端在部门服务中调用的雇员服务API方法的实现。

@RestController
public class EmployeeController {

    private static final Logger LOGGER = LoggerFactory
        .getLogger(EmployeeController.class);
    
    @Autowired
    EmployeeRepository repository;

    // ... other endpoints implementation 

    @GetMapping("/department/{departmentId}")
    public List<Employee> findByDepartment(@PathVariable("departmentId") String departmentId) {
        LOGGER.info("Employee find: departmentId={}", departmentId);
        return repository.findByDepartmentId(departmentId);
    }

    @GetMapping("/department-with-delay/{departmentId}")
    public List<Employee> findByDepartmentWithDelay(@PathVariable("departmentId") String departmentId) throws InterruptedException {
        LOGGER.info("Employee find: departmentId={}", departmentId);
        Thread.sleep(2000);
        return repository.findByDepartmentId(departmentId);
    }
    
}

这就是我们要做的一切。

现在，我们可以使用部门服务中的OpenFeign客户端调用端点。
例如，在 "延迟 "端点上，我们可以使用Spring Cloud Circuit Breaker与Resilience4J。

@RestController
public class DepartmentController {

    private static final Logger LOGGER = LoggerFactory
        .getLogger(DepartmentController.class);

    DepartmentRepository repository;
    EmployeeClient employeeClient;
    Resilience4JCircuitBreakerFactory circuitBreakerFactory;

    public DepartmentController(
        DepartmentRepository repository, 
        EmployeeClient employeeClient,
        Resilience4JCircuitBreakerFactory circuitBreakerFactory) {
            this.repository = repository;
            this.employeeClient = employeeClient;
            this.circuitBreakerFactory = circuitBreakerFactory;
    }

    @GetMapping("/{id}/with-employees-and-delay")
    public Department findByIdWithEmployeesAndDelay(@PathVariable("id") String id) {
        LOGGER.info("Department findByIdWithEmployees: id={}", id);
        Department department = repository.findById(id).orElseThrow();
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("delayed-circuit");
        List<Employee> employees = circuitBreaker.run(() ->
                employeeClient.findByDepartmentWithDelay(department.getId()));
        department.setEmployees(employees);
        return department;
    }

    @GetMapping("/organization/{organizationId}/with-employees")
    public List<Department> findByOrganizationWithEmployees(@PathVariable("organizationId") String organizationId) {
        LOGGER.info("Department find: organizationId={}", organizationId);
        List<Department> departments = repository.findByOrganizationId(organizationId);
        departments.forEach(d -> d.setEmployees(employeeClient.findByDepartment(d.getId())));
        return departments;
    }

}

在 k3s 上使用 Testcontainer 进行测试

正如我之前提到的，我们可以使用多种工具对 Kubernetes 进行测试。这次我们将看到如何使用 Testcomntainers 来完成它。我们已经在上一节中使用它来运行 Mongo 数据库。但是还有用于 Rancher 的 k3s Kubernetes 发行版的 Testcontainers 模块。目前，它处于孵化状态，不过我们也懒得去尝试。为了在项目中使用它，我们需要包含以下 Maven 依赖项：

<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>k3s</artifactId>
  <scope>test</scope>
</dependency>

代码：

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
        properties = {
                "spring.main.cloud-platform=KUBERNETES",
                "spring.cloud.bootstrap.enabled=true"})
@Testcontainers
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class EmployeeKubernetesTest {

   private static final Logger LOG = LoggerFactory
      .getLogger(EmployeeKubernetesTest.class);

   @Container
   static MongoDBContainer mongodb = new MongoDBContainer("mongo:5.0");
   @Container
   static K3sContainer k3s = new K3sContainer(DockerImageName
      .parse("rancher/k3s:v1.21.3-k3s1")); // (1)

   @BeforeAll
   static void setup() {
      Config config = Config
         .fromKubeconfig(k3s.getKubeConfigYaml()); // (2)
      DefaultKubernetesClient client = new 
         DefaultKubernetesClient(config); // (3)

      ConfigMap cm = client.configMaps().inNamespace("default")
         .create(buildConfigMap(mongodb.getMappedPort(27017)));
      LOG.info("!!! {}", cm); // (4)

      System.setProperty(Config.KUBERNETES_MASTER_SYSTEM_PROPERTY, 
         client.getConfiguration().getMasterUrl());
      
      // (5) 
      System.setProperty(Config.KUBERNETES_CLIENT_CERTIFICATE_DATA_SYSTEM_PROPERTY,
         client.getConfiguration().getClientCertData());
      System.setProperty(Config.KUBERNETES_CA_CERTIFICATE_DATA_SYSTEM_PROPERTY,
         client.getConfiguration().getCaCertData());
       System.setProperty(Config.KUBERNETES_CLIENT_KEY_DATA_SYSTEM_PROPERTY,
         client.getConfiguration().getClientKeyData());
      System.setProperty(Config.KUBERNETES_TRUST_CERT_SYSTEM_PROPERTY, 
         "true");
      System.setProperty(Config.KUBERNETES_NAMESPACE_SYSTEM_PROPERTY, 
         "default");
    }

    private static ConfigMap buildConfigMap(int port) {
        return new ConfigMapBuilder().withNewMetadata()
                .withName("employee").withNamespace("default")
                .endMetadata()
                .addToData("application.properties",
                        """
                        spring.data.mongodb.host=localhost
                        spring.data.mongodb.port=%d
                        spring.data.mongodb.database=test
                        spring.data.mongodb.authentication-database=test
                        """.formatted(port))
                .build();
    }

    @Autowired
    TestRestTemplate restTemplate;

    @Test
    @Order(1)
    void addEmployeeTest() {
        Employee employee = new Employee("1", "1", "Test", 30, "test");
        employee = restTemplate.postForObject("/", employee, Employee.class);
        assertNotNull(employee);
        assertNotNull(employee.getId());
    }

    @Test
    @Order(2)
    void addAndThenFindEmployeeByIdTest() {
        Employee employee = new Employee("1", "2", "Test2", 20, "test2");
        employee = restTemplate
           .postForObject("/", employee, Employee.class);
        assertNotNull(employee);
        assertNotNull(employee.getId());
        employee = restTemplate
                .getForObject("/{id}", Employee.class, employee.getId());
        assertNotNull(employee);
        assertNotNull(employee.getId());
    }

    @Test
    @Order(3)
    void findAllEmployeesTest() {
        Employee[] employees =
                restTemplate.getForObject("/", Employee[].class);
        assertEquals(2, employees.length);
    }

    @Test
    @Order(3)
    void findEmployeesByDepartmentTest() {
        Employee[] employees =
                restTemplate.getForObject("/department/1", Employee[].class);
        assertEquals(1, employees.length);
    }

    @Test
    @Order(3)
    void findEmployeesByOrganizationTest() {
        Employee[] employees =
                restTemplate.getForObject("/organization/1", Employee[].class);
        assertEquals(2, employees.length);
    }

}

我们不需要创建任何模拟。相反，我们将创建K3sContainer对象（1）。在运行测试之前，我们需要创建并初始化KubernetesClient。测试容器 K3sContainer提供了getKubeConfigYaml()方法来获取kubeconfig数据。有了Fabric8配置对象，我们可以从该kubeconfig（2）（3）初始化客户端。之后，我们将用Mongo连接细节创建ConfigMap（4）。最后，我们要为Spring Cloud Kubernetes自动配置的Fabric8客户端重写主URL。与上一节相比，我们还需要设置Kubernetes客户端证书和密钥（5）。

在Minikube上运行Spring Kubernetes应用程序
在这个练习中，我使用Minikube，但你也可以使用任何其他的发行版，如Kind或k3s。

Spring Cloud Kubernetes需要在Kubernetes上有额外的权限，以便能够与主API互动。
因此，在运行应用程序之前，我们将创建具有所需权限的spring-cloud-kubernetes ServiceAccount。我们的角色需要拥有对配置图、pods、服务、端点和机密的访问权。
如果我们没有启用跨所有命名空间的发现（spring.cloud.kubernetes.discovery.all-namespaces 属性），可以在命名空间内进行角色。否则，我们应该创建一个ClusterRole。

apiVersion: v1
kind: ServiceAccount
metadata:
  name: spring-cloud-kubernetes
  namespace: default
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: spring-cloud-kubernetes
  namespace: default
rules:
  - apiGroups: [""]
    resources: ["configmaps", "pods", "services", "endpoints", "secrets"]
    verbs: ["get", "list", "watch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: spring-cloud-kubernetes
  namespace: default
subjects:
  - kind: ServiceAccount
    name: spring-cloud-kubernetes
    namespace: default
roleRef:
  kind: ClusterRole
  name: spring-cloud-kubernetes

当然，你不需要自己去应用上面可见的清单。正如我在文章开头提到的，在版本库根目录文件中有一个 skaffold.yaml 文件，包含了整个配置。它与所有服务一起运行带有 Mongo 部署（1）和带有权限（2）的清单。

apiVersion: skaffold/v4beta5
kind: Config
metadata:
  name: sample-spring-microservices-kubernetes
build:
  artifacts:
    - image: piomin/admin
      jib:
        project: admin-service
    - image: piomin/department
      jib:
        project: department-service
        args:
          - -DskipTests
    - image: piomin/employee
      jib:
        project: employee-service
        args:
          - -DskipTests
    - image: piomin/gateway
      jib:
        project: gateway-service
    - image: piomin/organization
      jib:
        project: organization-service
        args:
          - -DskipTests
  tagPolicy:
    gitCommit: {}
manifests:
  rawYaml:
    - k8s/mongodb-*.yaml # (1)
    - k8s/privileges.yaml # (2)
    - admin-service/k8s/*.yaml
    - department-service/k8s/*.yaml
    - employee-service/k8s/*.yaml
    - gateway-service/k8s/*.yaml
    - organization-service/k8s/*.yaml

我们需要做的就是通过执行以下skaffold命令来部署所有的应用程序：

$ skaffold dev

最后的思考
如果你在Kubernetes集群上只运行Spring Boot应用，Spring Cloud Kubernetes是一个有趣的选择。它允许我们轻松地与Kubernetes发现、配置图和秘密集成。

正因为如此，我们可以利用其他Spring Cloud组件，如负载平衡器、断路器等。

然而，如果你正在运行用不同语言和框架编写的应用程序，并使用服务网（Istio、Linkerd）等语言无关的工具，Spring Cloud Kubernetes可能不是最佳选择。

Recommend

AirTunes signal injection and broadcast

akile|日本三网优化线路vps测评|去程CN2+9929+CMI|回程联通软银|移动CMI|电信IIJ|月付...

M2 Ultra Geekbench Scores | MacRumors Forums

Anybody here actually leave stage manager on? And like it? | MacRumors Forums

Can a chatbot preach a good sermon? Hundreds attend church service generated by...

Microsoft Build 2023: Bing AI and Copilot Plugins for ChatGPT OpenAI, Microsoft...

Meta's Zuckerberg shakes off Apple Vision Pro: report

KYOCERA Programming Contest 2023（AtCoder Beginner Contest 305） Announcement

快速排序 C实现

插入排序 C实现

About Joyk