Kubernetes Client

Quarkus 包含 kubernetes-client 扩展，它支持在原生模式中使用 Fabric8 Kubernetes Client，同时也使用户更容易对其进行操作。 Quarkus 中有 Kubernetes 客户端扩展对于解锁 Kubernetes Operators 非常有用。Kubernetes Operators 正迅速成为一类新的云原生应用程序。这些应用程序本质上会监视 Kubernetes API 并对各种资源上的更改做出反应，并且可用于管理所有类型复杂系统的生命周期，如数据库、消息系统等等。能够使用原生映像提供的极低开销用 Java 编写这样的操作员非常匹配。

Configuration

配置好 Quarkus 项目后，您可以通过在项目基目录中运行以下命令将 kubernetes-client 扩展添加到项目。

CLI
quarkus extension add {add-extension-extensions}
Maven
./mvnw quarkus:add-extension -Dextensions='{add-extension-extensions}'
Gradle
./gradlew addExtension --extensions='{add-extension-extensions}'

这会将以下内容添加到构建文件中：

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-kubernetes-client</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-kubernetes-client")

Usage

Quarkus 配置了 KubernetesClient 类型的 Bean，可以使用常见的 CDI 方法将其注入到应用程序代码中。此客户机可以通过各种属性进行配置，如下例所示：

quarkus.kubernetes-client.trust-certs=false
quarkus.kubernetes-client.namespace=default

请注意，完整属性列表在 Dev Services section of the configuration reference 中可用。

在开发模式和运行测试时，Dev Services for Kubernetes 会自动启动 Kubernetes API 服务器。

Customizing and overriding

Quarkus 提供多个集成点，以影响作为 CDI bean 提供的 Kubernetes Client。

Kubernetes Client Config customization

第一个集成点是使用 io.quarkus.kubernetes.client.KubernetesConfigCustomizer 接口。当存在这样的 Bean 时，它允许对 Quarkus 创建的 io.fabric8.kubernetes.client.Config 进行任意自定义（考虑了 quarkus.kubernetes-client.* 属性）。

或者，应用程序代码可以通过简单地声明这些 bean 的自定义版本来覆盖 io.fabric8.kubernetes.client.Config 甚至 io.fabric8.kubernetes.client.KubernetesClient bean（这些 bean 通常由扩展提供）。

以下代码段中可以找到一个示例：

@Singleton
public class KubernetesClientProducer {

    @Produces
    public KubernetesClient kubernetesClient() {
        // here you would create a custom client
        return new DefaultKubernetesClient();
    }
}

Kubernetes Client ObjectMapper customization

Fabric8 Kubernetes Client 使用自己的 ObjectMapper 实例来序列化和反序列化 Kubernetes 资源。此映射器通过注入到 KubernetesClient bean 中的 KubernetesSerialization 实例提供给客户端。

如果出于某种原因必须自定义此扩展提供的并由 Kubernetes Client 使用的默认 ObjectMapper bean，则可以通过声明实现 KubernetesClientObjectMapperCustomizer 接口的 bean 来执行此操作。

以下代码段包含 KubernetesClientObjectMapperCustomizer 的示例，用于设置 ObjectMapper 本地语言：

@Singleton
public static class Customizer implements KubernetesClientObjectMapperCustomizer {
    @Override
    public void customize(ObjectMapper objectMapper) {
        objectMapper.setLocale(Locale.ROOT);
    }
}

此外，如果必须替换扩展自动创建的 Kubernetes Client 使用的默认 ObjectMapper bean，则可以通过声明 @KubernetesClientObjectMapper 类型 bean 来执行此操作。以下代码段展示了如何声明此 bean：

@Singleton
public class KubernetesObjectMapperProducer {
    @KubernetesClientObjectMapper
    @Singleton
    @Produces
    public ObjectMapper kubernetesClientObjectMapper() {
        return new ObjectMapper();
    }
}

静态 io.fabric8.kubernetes.client.utils.Serialization 实用程序类已弃用，不应使用。对 Serialization.jsonMapper() 的访问应替换为使用声明的 @KubernetesClientObjectMapperCustomizer`。

Testing

为了让针对模拟 Kubernetes API 服务器的测试非常简单，Quarkus 提供了 WithKubernetesTestServer 注释，该注释会自动启动 Kubernetes API 服务器 simulatio，并设置 Kubernetes Client 配置自身以使用该模拟所需的环境变量。测试可以使用 @KubernetesTestServer 注释注入模拟服务器，并以特定测试所需的任何方式设置它。

假设我们有一个这样定义的 REST 端点：

@Path("/pod")
public class Pods {

    private final KubernetesClient kubernetesClient;

    public Pods(KubernetesClient kubernetesClient) {
        this.kubernetesClient = kubernetesClient;
    }

    @GET
    @Path("/{namespace}")
    public List<Pod> pods(String namespace) {
        return kubernetesClient.pods().inNamespace(namespace).list().getItems();
    }
}

我们可以像这样非常轻松地为这个端点编写一个测试：

// you can even configure aspects like crud, https and port on this annotation
@WithKubernetesTestServer
@QuarkusTest
public class KubernetesClientTest {

    @KubernetesTestServer
    KubernetesServer mockServer;
    @Inject
    KubernetesClient client;

    @BeforeEach
    public void before() {
        final Pod pod1 = new PodBuilder().withNewMetadata().withName("pod1").withNamespace("test").and().build();
        final Pod pod2 = new PodBuilder().withNewMetadata().withName("pod2").withNamespace("test").and().build();

        // Set up Kubernetes so that our "pretend" pods are created
        client.pods().resource(pod1).create();
        client.pods().resource(pod2).create();
    }

    @Test
    public void testInteractionWithAPIServer() {
        RestAssured.when().get("/pod/test").then()
                .body("size()", is(2));
    }

}

请注意，要利用这些功能，需要添加 quarkus-test-kubernetes-client 依赖项，例如如下所示：

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-test-kubernetes-client</artifactId>
    <scope>test</scope>
</dependency>
build.gradle
testImplementation("io.quarkus:quarkus-test-kubernetes-client")

默认情况下，模拟服务器将处于 CRUD 模式，因此在应用程序可以检索该状态之前，必须使用客户端构建该状态，但你也可以以非 CRUD 模式对其进行设置，并模拟对 Kubernetes 进行的所有 HTTP 请求：

// you can even configure aspects like crud, https and port on this annotation
@WithKubernetesTestServer(crud = false)
@QuarkusTest
public class KubernetesClientTest {

    @KubernetesTestServer
    KubernetesServer mockServer;

    @BeforeEach
    public void before() {
        final Pod pod1 = new PodBuilder().withNewMetadata().withName("pod1").withNamespace("test").and().build();
        final Pod pod2 = new PodBuilder().withNewMetadata().withName("pod2").withNamespace("test").and().build();

        // Mock any HTTP request to Kubernetes pods so that our pods are returned
        mockServer.expect().get().withPath("/api/v1/namespaces/test/pods")
                .andReturn(200,
                        new PodListBuilder().withNewMetadata().withResourceVersion("1").endMetadata().withItems(pod1, pod2)
                                .build())
                .always();
    }

    @Test
    public void testInteractionWithAPIServer() {
        RestAssured.when().get("/pod/test").then()
                .body("size()", is(2));
    }

}

你还可以对 @WithKubernetesTestServer 注释使用 setup 属性，以提供一个类来配置 KubernetesServer 实例：

@WithKubernetesTestServer(setup = MyTest.Setup.class)
@QuarkusTest
public class MyTest {

    public static class Setup implements Consumer<KubernetesServer> {

        @Override
        public void accept(KubernetesServer server) {
          server.expect().get().withPath("/api/v1/namespaces/test/pods")
            .andReturn(200, new PodList()).always();
        }
    }

    // tests
}

或者，你可以创建 KubernetesServerTestResource 类的扩展，以确保所有启用了 @QuarkusTest 的测试类通过 WithTestResource 注释共享相同的模拟服务器设置：

public class CustomKubernetesMockServerTestResource extends KubernetesServerTestResource {

    @Override
    protected void configureServer() {
        super.configureServer();
        server.expect().get().withPath("/api/v1/namespaces/test/pods")
          .andReturn(200, new PodList()).always();
    }
}

并在其他测试类中按如下方式使用它：

@WithTestResource(CustomKubernetesMockServerTestResource.class)
@QuarkusTest
public class KubernetesClientTest {

    //tests will now use the configured server...
}

Note on implementing or extending generic types

由于 GraalVM 施加的限制，如果应用程序要在原生模式下运行，在实现或扩展客户端提供的泛型类型时需要格外小心。本质上，Watcher、ResourceHandler 或 CustomResource 等泛型类的每个实现或扩展都需要在类定义时间指定其关联的 Kubernetes 模型类（或在 CustomResource 的情况下是常规 Java 类型）。为了更好地理解这一点，假设我们要监视 Kubernetes Pod 资源的更改。有几种编写此类 Watcher 的方法可以确保原生模式下工作：

client.pods().watch(new Watcher<Pod>() {
    @Override
    public void eventReceived(Action action, Pod pod) {
        // do something
    }

    @Override
    public void onClose(KubernetesClientException e) {
        // do something
    }
});

或

public class PodResourceWatcher implements Watcher<Pod> {
    @Override
    public void eventReceived(Action action, Pod pod) {
        // do something
    }

    @Override
    public void onClose(KubernetesClientException e) {
        // do something
    }
}

...


client.pods().watch(new PodResourceWatcher());

请注意，通过类似于以下示例的类层次结构定义泛型类型也能正常工作：

public abstract class MyWatcher<S> implements Watcher<S> {
}

...


client.pods().watch(new MyWatcher<Pod>() {
    @Override
    public void eventReceived(Action action, Pod pod) {
        // do something
    }
});

以下示例将在原生模式下 not 工作，因为无法通过查看类和方法定义来确定观察者的泛型类型，因此让 Quarkus 无法正确确定需要进行反射注册的 Kubernetes 模型类：

public class ResourceWatcher<T extends HasMetadata> implements Watcher<T> {
    @Override
    public void eventReceived(Action action, T resource) {
        // do something
    }

    @Override
    public void onClose(KubernetesClientException e) {
        // do something
    }
}

client.pods().watch(new ResourceWatcher<Pod>());

Note on using Elliptic Curve keys

请注意，如果您想在 Kubernetes 客户端中使用椭圆曲线密钥，则需要添加 BouncyCastle PKIX 依赖项：

pom.xml
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpkix-jdk18on</artifactId>
</dependency>
build.gradle
implementation("org.bouncycastle:bcpkix-jdk18on")

请注意，如果 org.bouncycastle.jce.provider.BouncyCastleProvider 提供程序尚未注册，则内部将会自动注册此提供程序。

您可以按照 BouncyCastle 或 BouncyCastle FIPS 部分中的说明将此提供程序注册。

Access to the Kubernetes API

在很多情况下，为了访问 Kubernetes API 服务器，需要 ServiceAccount、Role 和 RoleBinding。下面是一个列出所有 pod 的示例：

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: <applicationName>
  namespace: <namespace>
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: <applicationName>
  namespace: <namespace>
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: <applicationName>
  namespace: <namespace>
roleRef:
  kind: Role
  name: <applicationName>
  apiGroup: rbac.authorization.k8s.io
subjects:
  - kind: ServiceAccount
    name: <applicationName>
    namespace: <namespace>

将 <applicationName> 和 <namespace> 替换为您自己的值。有关更多信息，请参考 Configure Service Accounts for Pods。

OpenShift Client

如果目标 Kubernetes 集群是 OpenShift 集群，则可以通过以下 openshift-client 扩展以类似方式访问它。这利用了专用的 fabric8openshift 客户端，并提供访问 OpenShift 专有对象（例如 Route、ProjectRequest、BuildConfig 等）的权限。

请注意，配置属性与 kubernetes-client 扩展共享。特别是，它们具有相同的 quarkus.kubernetes-client 前缀。

使用以下命令添加扩展：

CLI
quarkus extension add {add-extension-extensions}
Maven
./mvnw quarkus:add-extension -Dextensions='{add-extension-extensions}'
Gradle
./gradlew addExtension --extensions='{add-extension-extensions}'

请注意，openshift-client 扩展依赖于 kubernetes-client 扩展。

要使用客户端，请注入 OpenShiftClient，而不是 KubernetesClient：

@Inject
private OpenShiftClient openshiftClient;

如果您需要覆盖默认 OpenShiftClient，请提供一个生产者，例如：

@Singleton
public class OpenShiftClientProducer {

    @Produces
    public OpenShiftClient openshiftClient() {
        // here you would create a custom client
        return new DefaultOpenShiftClient();
    }
}

还以类似的方式提供模拟支持：

@WithTestResource(OpenShiftMockServerTestResource.class)
@QuarkusTest
public class OpenShiftClientTest {

    @MockServer
    private OpenShiftMockServer mockServer;
...

或者通过使用 @WithOpenShiftTestServer，类似于前一部分中解释的 @WithKubernetesTestServer：

@WithOpenShiftTestServer
@QuarkusTest
public class OpenShiftClientTest {

    @OpenShiftTestServer
    private OpenShiftServer mockOpenShiftServer;
...

要使用此功能，您必须添加对 quarkus-test-openshift-client 的依赖：

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-test-openshift-client</artifactId>
    <scope>test</scope>
</dependency>
build.gradle
testImplementation("io.quarkus:quarkus-test-openshift-client")

Configuration Reference

Unresolved include directive in modules/ROOT/pages/kubernetes-client.adoc - include::../../../target/quarkus-generated-doc/config/quarkus-kubernetes-client.adoc[]