【探索实战】Kurator集群算子自定义扩展与多场景落地

一、企业级运维的个性化需求与集群算子扩展方案

在大型企业的复杂运维场景中，通用型集群管理工具往往难以满足个性化需求：

1. 异构环境适配难：混合云（公有云 + 私有云 + 边缘）集群的底层架构、网络配置差异大，通用算子能力无法全覆盖；

2. 自定义运维流程缺失：企业专属运维规范（如自研组件部署、合规校验流程、内部工具集成）难以融入现有管理体系；

3. 行业场景适配不足：金融、制造、医疗等行业的特殊需求（如金融级安全加固、制造场景边缘节点管理）缺乏针对性支持；

4. 现有系统集成复杂：需与企业内部 CMDB、工单系统、监控平台打通，通用工具的集成能力有限。

Kurator 集群算子的插件化扩展架构，正是为解决这些问题而生 —— 通过 “核心算子 + 自定义插件” 的模式，支持企业基于业务需求扩展运维能力，实现三大核心价值：

• 异构环境统一管控：开发自定义插件适配不同类型集群（私有云 / 边缘 / 异构架构），实现混合云一体化管理；

• 个性化流程自动化：将企业专属运维流程封装为插件，融入集群全生命周期管理；

• 多系统无缝集成：通过插件对接内部系统，实现运维数据互通与流程闭环。

二、集群算子扩展架构解析

Kurator 集群算子的扩展能力基于 “插件化框架 + CRD 扩展” 实现，核心架构包含三部分：

1. 核心算子框架：提供插件注册、生命周期管理、状态调和等基础能力，定义插件接口规范；

2. 插件层：分为内置插件（集群创建、升级、备份等）和自定义插件（企业专属能力），插件通过接口与核心框架交互；

3. 扩展 CRD：支持自定义 CRD 定义个性化运维策略，核心算子通过监听扩展 CRD 触发插件执行。

插件的核心工作流程：

1. 开发插件：遵循 Kurator 插件接口规范，实现自定义运维逻辑（如私有云集群部署、合规校验）；

2. 注册插件：通过配置文件将插件注册到集群算子核心框架；

3. 定义扩展 CRD：创建自定义 CRD，声明插件的执行策略（如触发条件、参数配置）；

4. 触发执行：核心算子监听扩展 CRD 状态变化，调用插件执行自定义逻辑，完成状态调和。

三、实战：集群算子自定义扩展与多场景落地

1. 环境前置条件

• 已部署 Kurator 控制平面（v0.7.1+），支持插件扩展（开启plugin-enabled配置）；

• 已具备 Go 开发环境（Go 1.19+），熟悉 Kubernetes Operator 开发规范；

• 目标环境：混合云集群（私有云 VMware 集群、边缘 ARM 集群、阿里云 ECS 集群）；

• 企业内部系统：CMDB（存储集群元数据）、工单系统（运维流程审批）、自研安全加固工具。

2. 场景一：自定义插件开发 —— 私有云 VMware 集群适配

企业私有云基于 VMware vSphere 构建，需开发自定义插件实现 VMware 集群的自动化创建与管理。

2.1 插件开发：VMware 集群部署插件

遵循 Kurator 插件接口规范，开发vmware-provisioner插件，核心功能包括：

• 调用 VMware vSphere API 创建虚拟机；

• 在虚拟机上部署 Kubernetes 集群；

• 配置 VMware 专属网络（VXLAN）与存储（vSAN）。

步骤 1：定义插件接口实现

插件需实现ClusterProvisioner接口，核心代码片段：

// vmware_provisioner.go
package vmwareprovisioner

import (
  "context"
  "fmt"

  "github.com/kurator-dev/kurator/pkg/operator/cluster/plugin"
  v1 "k8s.io/api/core/v1"
  "k8s.io/apimachinery/pkg/runtime"
  "sigs.k8s.io/controller-runtime/pkg/client"
)

// VMwareProvisioner 实现ClusterProvisioner接口
type VMwareProvisioner struct {
  Client    client.Client
  Scheme    *runtime.Scheme
  VSphereConfig VSphereConfig // VMware配置
}

// Provision 实现集群创建逻辑
func (p *VMwareProvisioner) Provision(ctx context.Context, cluster *plugin.Cluster) error {
  // 1. 从Secret获取VMware凭证
  err := p.getVSphereCredential(ctx, cluster.Credential.SecretRef.Name)
  if err != nil {
    return fmt.Errorf("获取VMware凭证失败: %v", err)
  }

  // 2. 调用vSphere API创建虚拟机（主节点+工作节点）
  err = p.createVMs(ctx, cluster)
  if err != nil {
    return fmt.Errorf("创建VMware虚拟机失败: %v", err)
  }

  // 3. 在虚拟机上部署Kubernetes集群
  err = p.deployK8sCluster(ctx, cluster)
  if err != nil {
    return fmt.Errorf("部署K8s集群失败: %v", err)
  }

  // 4. 配置VMware vSAN存储与VXLAN网络
  err = p.configureNetworkAndStorage(ctx, cluster)
  if err != nil {
    return fmt.Errorf("配置网络存储失败: %v", err)
  }

  return nil
}

// 其他接口实现（Destroy/Upgrade/Scale等）

步骤 2：注册插件到 Kurator 核心算子

创建插件配置文件，将vmware-provisioner注册到集群算子：

# plugin-config.yaml
apiVersion: kurator.dev/v1alpha1
kind: PluginConfig
metadata:
  name: vmware-provisioner-config
  namespace: kurator-system
spec:
  plugins:
  - name: vmware-provisioner
    type: ClusterProvisioner
    image: your-registry/vmware-provisioner:v1.0.0  # 插件镜像
    config:
      vSphereEndpoint: https://vcenter.example.com/sdk  # VMware vCenter地址

应用插件配置：

kubectl apply -f plugin-config.yaml

# 验证插件注册成功
kubectl get pluginconfigs -n kurator-system

2.2 声明式创建 VMware 私有云集群

通过扩展ClusterCRD，指定provider: vmware，集群算子自动调用vmware-provisioner插件创建集群：

# vmware-cluster.yaml
apiVersion: cluster.kurator.dev/v1alpha1
kind: Cluster
metadata:
  name: vmware-private-cluster
  namespace: kurator-system
spec:
  kind: Provisioned
  provider: vmware  # 指定VMware provider，触发自定义插件
  version: v1.26.5
  # VMware专属配置（插件需解析的参数）
  vmwareConfig:
    datacenter: DC-01
    cluster: VMware-Cluster-01
    datastore: vSAN-Datastore
    network: VM-Network
  nodePools:
  - name: master-pool
    type: Master
    vmSpec:
      template: Kubernetes-Master-Template  # VMware虚拟机模板
      cpu: 8
      memory: 16Gi
      diskSize: 200Gi
    replicas: 3
  - name: worker-pool
    type: Worker
    vmSpec:
      template: Kubernetes-Worker-Template
      cpu: 16
      memory: 32Gi
      diskSize: 500Gi
    replicas: 6
  network:
    networkType: calico
    podCIDR: 10.246.0.0/16
  credential:
    secretRef:
      name: vmware-credential  # VMware凭证Secret

创建 VMware 凭证 Secret 并应用集群配置：

# 创建凭证Secret
kubectl create secret generic vmware-credential \
  --namespace=kurator-system \
  --from-literal=username=administrator@vsphere.local \
  --from-literal=password=xxx

# 应用集群配置，触发插件执行
kubectl apply -f vmware-cluster.yaml

# 查看集群创建状态
kubectl get clusters -n kurator-system -w

集群算子调用vmware-provisioner插件，自动完成 VMware 虚拟机创建、K8s 部署、网络存储配置，实现私有云集群自动化管理。

3. 场景二：自定义 CRD 扩展 —— 企业合规校验流程

企业需在集群创建后执行专属合规校验（如禁用 root 用户、配置安全组、安装自研安全代理），通过自定义 CRD 与插件实现流程自动化。

3.1 定义扩展 CRD：ClusterCompliance

创建自定义 CRD，声明合规校验规则：

# clustercompliance-crd.yaml
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: clustercompliances.cluster.kurator.dev
spec:
  group: cluster.kurator.dev
  names:
    kind: ClusterCompliance
    listKind: ClusterComplianceList
    plural: clustercompliances
    singular: clustercompliance
  scope: Namespaced
  versions:
  - name: v1alpha1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        type: object
        properties:
          spec:
            type: object
            properties:
              clusterName:
                type: string
              rules:
                type: array
                items:
                  type: object
                  properties:
                    name:
                      type: string
                    type:
                      type: string
                    enabled:
                      type: boolean
                    params:
                      type: object
            required:
            - clusterName
            - rules
          status:
            type: object
            properties:
              phase:
                type: string
              complianceResult:
                type: array
                items:
                  type: object
                  properties:
                    ruleName:
                      type: string
                    status:
                      type: string
                    message:
                      type: string

应用 CRD：

kubectl apply -f clustercompliance-crd.yaml

3.2 开发合规校验插件

开发cluster-compliance插件，监听ClusterComplianceCRD，执行合规校验逻辑：

• 禁用容器 root 用户运行；

• 配置企业安全组规则；

• 安装自研安全代理组件；

• 校验节点 SSH 访问权限。

核心代码片段：

// compliance_plugin.go
package complianceplugin

import (
  "context"
  "fmt"

  "github.com/kurator-dev/kurator/pkg/operator/cluster/plugin"
  clusterv1alpha1 "github.com/your-org/kurator-plugins/api/v1alpha1"
  "k8s.io/apimachinery/pkg/types"
)

type ClusterCompliancePlugin struct {
  Client client.Client
}

// Run 执行合规校验
func (p *ClusterCompliancePlugin) Run(ctx context.Context, compliance *clusterv1alpha1.ClusterCompliance) error {
  // 1. 获取目标集群的kubeconfig
  kubeconfig, err := p.getClusterKubeconfig(ctx, compliance.Spec.ClusterName)
  if err != nil {
    return fmt.Errorf("获取集群kubeconfig失败: %v", err)
  }

  // 2. 初始化集群客户端
  clusterClient, err := p.initClusterClient(kubeconfig)
  if err != nil {
    return fmt.Errorf("初始化集群客户端失败: %v", err)
  }

  // 3. 执行所有合规规则
  results := make([]clusterv1alpha1.ComplianceResult, 0)
  for _, rule := range compliance.Spec.Rules {
    if !rule.Enabled {
      continue
    }
    result := p.executeRule(ctx, clusterClient, rule)
    results = append(results, result)
  }

  // 4. 更新CRD状态
  compliance.Status.ComplianceResult = results
  compliance.Status.Phase = p.getCompliancePhase(results)
  return p.Client.Status().Update(ctx, compliance)
}

// 执行单个合规规则
func (p *ClusterCompliancePlugin) executeRule(ctx context.Context, client client.Client, rule clusterv1alpha1.ComplianceRule) clusterv1alpha1.ComplianceResult {
  switch rule.Type {
  case "disable-root-user":
    return p.disableRootUser(ctx, client, rule)
  case "configure-security-group":
    return p.configureSecurityGroup(ctx, client, rule)
  case "install-security-agent":
    return p.installSecurityAgent(ctx, client, rule)
  default:
    return clusterv1alpha1.ComplianceResult{
      RuleName: rule.Name,
      Status:   "Failed",
      Message:  fmt.Sprintf("未知合规规则类型: %s", rule.Type),
    }
  }
}

3.3 应用合规校验配置

创建ClusterCompliance资源，触发插件执行合规校验：

# cluster-compliance.yaml
apiVersion: cluster.kurator.dev/v1alpha1
kind: ClusterCompliance
metadata:
  name: prod-cluster-compliance
  namespace: kurator-system
spec:
  clusterName: prod-cluster  # 目标集群
  rules:
  - name: disable-root-user
    type: disable-root-user
    enabled: true
    params:
      enforce: true  # 强制启用（不满足则阻断集群使用）
  - name: configure-security-group
    type: configure-security-group
    enabled: true
    params:
      allowPorts: [80, 443, 6443]
      denyPorts: [22, 3389]
  - name: install-security-agent
    type: install-security-agent
    enabled: true
    params:
      agentImage: your-registry/security-agent:v2.0.0
      namespace: security-infra

应用配置并验证：

kubectl apply -f cluster-compliance.yaml

# 查看合规校验状态
kubectl get clustercompliances -n kurator-system -w

# 查看详细校验结果
kubectl describe clustercompliance prod-cluster-compliance -n kurator-system

若合规校验未通过（如存在 root 用户运行的容器），插件会根据enforce: true配置阻断集群使用，直到修复合规问题。

4. 场景三：多系统集成 —— 对接 CMDB 与工单系统

企业需将集群信息同步到 CMDB，并在集群升级前触发工单审批，通过插件实现多系统集成。

4.1 开发集成插件

开发cmdb-ticket-integrator插件，核心功能：

• 集群创建 / 更新后，同步元数据到 CMDB；

• 集群升级前，调用工单系统创建审批工单，审批通过后再执行升级。

核心代码片段：

// integrator_plugin.go
package integratorplugin

import (
  "context"
  "fmt"
  "time"

  "github.com/kurator-dev/kurator/pkg/operator/cluster/plugin"
  "github.com/your-org/cmdb-client"
  "github.com/your-org/ticket-client"
)

type CMDBTicketIntegrator struct {
  CMDBConfig    CMDBConfig
  TicketConfig  TicketConfig
  CMDB Client    *cmdb.Client
  TicketClient  *ticket.Client
}

// 集群创建后同步CMDB
func (i *CMDBTicketIntegrator) SyncToCMDB(ctx context.Context, cluster *plugin.Cluster) error {
  // 1. 构建CMDB集群元数据
  cmdbCluster := &cmdb.Cluster{
    Name:        cluster.Name,
    Provider:    cluster.Provider,
    Version:     cluster.Version,
    NodeCount:   cluster.GetNodeCount(),
    Status:      string(cluster.Status.Phase),
    CreateTime:  time.Now().Format(time.RFC3339),
  }

  // 2. 调用CMDB API同步数据
  err := i.CMDB.Client.CreateOrUpdateCluster(ctx, cmdbCluster)
  if err != nil {
    return fmt.Errorf("同步CMDB失败: %v", err)
  }
  return nil
}

// 集群升级前创建工单审批
func (i *CMDBTicketIntegrator) CreateUpgradeTicket(ctx context.Context, upgrade *plugin.ClusterUpgrade) error {
  // 1. 构建工单信息
  ticket := &ticket.Ticket{
    Title:       fmt.Sprintf("集群升级审批: %s -> %s", upgrade.ClusterName, upgrade.TargetVersion),
    Type:        "cluster-upgrade",
    Status:      "pending",
    Content:     fmt.Sprintf("集群%s需从%s升级到%s，请审批", upgrade.ClusterName, upgrade.CurrentVersion, upgrade.TargetVersion),
    Applicant:   "kurator-operator",
    Approvers:   []string{"infra-admin", "tech-lead"},
  }

  // 2. 调用工单系统API创建工单
  ticketID, err := i.TicketClient.CreateTicket(ctx, ticket)
 </doubaocanvas>