5.6. 基于 Java 的 Operator

流程

1. 创建一个项目。

   1. 创建您的项目目录：

      $ mkdir memcached-operator

   2. 切换到项目所在的目录：

      $ cd memcached-operator

   3. 使用 quarkus 插件运行 operator-sdk init 命令以初始化项目：

      $ operator-sdk init \
          --plugins=quarkus \
          --domain=example.com \
          --project-name=memcached-operator

2. 创建 API。

   创建简单的 Memcached API：

   $ operator-sdk create api \
       --plugins quarkus \
       --group cache \
       --version v1 \
       --kind Memcached

3. 构建并推送 Operator 镜像。

   使用默认的 Makefile 目标来构建和推送 Operator。使用镜像的 pull spec 设置 IMG，该 spec 使用您可推送到的 registry：

   $ make docker-build docker-push IMG=<registry>/<user>/<image_name>:<tag>

4. 运行 Operator。

   1. 安装 CRD：

      $ make install

   2. 将项目部署到集群中。将 IMG 设置为您推送的镜像：

      $ make deploy IMG=<registry>/<user>/<image_name>:<tag>

5. 创建示例自定义资源（CR）。

   1. 创建一个示例 CR：

      $ oc apply -f config/samples/cache_v1_memcached.yaml \
          -n memcached-operator-system

   2. 查看 CR 协调 Operator：

      $ oc logs deployment.apps/memcached-operator-controller-manager \
          -c manager \
          -n memcached-operator-system

6. 删除 CR

   运行以下命令来删除 CR：

   $ oc delete -f config/samples/cache_v1_memcached -n memcached-operator-system

7. 清理。

   运行以下命令清理在此流程中创建的资源：

   $ make undeploy

流程

1. 为项目创建一个目录：

   $ mkdir -p $HOME/projects/memcached-operator

2. 进入该目录：

   $ cd $HOME/projects/memcached-operator

3. 使用 quarkus 插件运行 operator-sdk init 命令以初始化项目：

   $ operator-sdk init \
       --plugins=quarkus \
       --domain=example.com \
       --project-name=memcached-operator

流程

1. 运行以下命令来创建 API：

   $ operator-sdk create api \
       --plugins=quarkus \ 1
       --group=cache \ 2
       --version=v1 \ 3
       --kind=Memcached 4

   1

   将插件标志设置为 quarkus。

   2

   将 group 标志设置为 cache。

   3

   将 version 标志设置为 v1。

   4

   将 kind 标志设置为 Memcached。

验证

1. 运行 tree 命令来查看文件结构：

   $ tree

   输出示例

   .
   ├── Makefile
   ├── PROJECT
   ├── pom.xml
   └── src
       └── main
           ├── java
           │   └── com
           │       └── example
           │           ├── Memcached.java
           │           ├── MemcachedReconciler.java
           │           ├── MemcachedSpec.java
           │           └── MemcachedStatus.java
           └── resources
               └── application.properties
   
   6 directories, 8 files

流程

1. 将以下依赖项附加到 pom.xml 文件中：

       <dependency>
         <groupId>commons-collections</groupId>
         <artifactId>commons-collections</artifactId>
         <version>3.2.2</version>
       </dependency>

2. 在本例中，将生成的控制器文件 MemcachedReconciler.java 替换为以下示例实现：

   例 5.9. MemcachedReconciler.java 示例

   package com.example;
   
   import io.fabric8.kubernetes.client.KubernetesClient;
   import io.javaoperatorsdk.operator.api.reconciler.Context;
   import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
   import io.javaoperatorsdk.operator.api.reconciler.UpdateControl;
   import io.fabric8.kubernetes.api.model.ContainerBuilder;
   import io.fabric8.kubernetes.api.model.ContainerPortBuilder;
   import io.fabric8.kubernetes.api.model.LabelSelectorBuilder;
   import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
   import io.fabric8.kubernetes.api.model.OwnerReferenceBuilder;
   import io.fabric8.kubernetes.api.model.Pod;
   import io.fabric8.kubernetes.api.model.PodSpecBuilder;
   import io.fabric8.kubernetes.api.model.PodTemplateSpecBuilder;
   import io.fabric8.kubernetes.api.model.apps.Deployment;
   import io.fabric8.kubernetes.api.model.apps.DeploymentBuilder;
   import io.fabric8.kubernetes.api.model.apps.DeploymentSpecBuilder;
   import org.apache.commons.collections.CollectionUtils;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.stream.Collectors;
   
   public class MemcachedReconciler implements Reconciler<Memcached> {
     private final KubernetesClient client;
   
     public MemcachedReconciler(KubernetesClient client) {
       this.client = client;
     }
   
     // TODO Fill in the rest of the reconciler
   
     @Override
     public UpdateControl<Memcached> reconcile(
         Memcached resource, Context context) {
         // TODO: fill in logic
         Deployment deployment = client.apps()
                 .deployments()
                 .inNamespace(resource.getMetadata().getNamespace())
                 .withName(resource.getMetadata().getName())
                 .get();
   
         if (deployment == null) {
             Deployment newDeployment = createMemcachedDeployment(resource);
             client.apps().deployments().create(newDeployment);
             return UpdateControl.noUpdate();
         }
   
         int currentReplicas = deployment.getSpec().getReplicas();
         int requiredReplicas = resource.getSpec().getSize();
   
         if (currentReplicas != requiredReplicas) {
             deployment.getSpec().setReplicas(requiredReplicas);
             client.apps().deployments().createOrReplace(deployment);
             return UpdateControl.noUpdate();
         }
   
         List<Pod> pods = client.pods()
             .inNamespace(resource.getMetadata().getNamespace())
             .withLabels(labelsForMemcached(resource))
             .list()
             .getItems();
   
         List<String> podNames =
             pods.stream().map(p -> p.getMetadata().getName()).collect(Collectors.toList());
   
   
         if (resource.getStatus() == null
                  || !CollectionUtils.isEqualCollection(podNames, resource.getStatus().getNodes())) {
              if (resource.getStatus() == null) resource.setStatus(new MemcachedStatus());
              resource.getStatus().setNodes(podNames);
              return UpdateControl.updateResource(resource);
         }
   
         return UpdateControl.noUpdate();
     }
   
     private Map<String, String> labelsForMemcached(Memcached m) {
       Map<String, String> labels = new HashMap<>();
       labels.put("app", "memcached");
       labels.put("memcached_cr", m.getMetadata().getName());
       return labels;
     }
   
     private Deployment createMemcachedDeployment(Memcached m) {
         Deployment deployment = new DeploymentBuilder()
             .withMetadata(
                 new ObjectMetaBuilder()
                     .withName(m.getMetadata().getName())
                     .withNamespace(m.getMetadata().getNamespace())
                     .build())
             .withSpec(
                 new DeploymentSpecBuilder()
                     .withReplicas(m.getSpec().getSize())
                     .withSelector(
                         new LabelSelectorBuilder().withMatchLabels(labelsForMemcached(m)).build())
                     .withTemplate(
                         new PodTemplateSpecBuilder()
                             .withMetadata(
                                 new ObjectMetaBuilder().withLabels(labelsForMemcached(m)).build())
                             .withSpec(
                                 new PodSpecBuilder()
                                     .withContainers(
                                         new ContainerBuilder()
                                             .withImage("memcached:1.4.36-alpine")
                                             .withName("memcached")
                                             .withCommand("memcached", "-m=64", "-o", "modern", "-v")
                                             .withPorts(
                                                 new ContainerPortBuilder()
                                                     .withContainerPort(11211)
                                                     .withName("memcached")
                                                     .build())
                                             .build())
                                     .build())
                             .build())
                     .build())
             .build();
       deployment.addOwnerReference(m);
       return deployment;
     }
   }

   示例控制器为每个 Memcached 自定义资源（CR）运行以下协调逻辑：

   • 如果尚无 Memcached 部署，请创建一个。
   • 确保部署大小与 Memcached CR spec 指定的大小匹配。
   • 使用 memcached Pod 的名称更新 Memcached CR 状态。