分享：operator开发基本流程

Kubernetes Golang

在 Golang 中开发一个 Kubernetes Operator 是一种强大的方式，用于管理复杂集群资源和自动化任务。以下是基于 Golang 开发一个 Operator 的完整流程，包括用到的工具、步骤以及最佳实践。我们主要依赖主流的 controller-runtime 和 Kubebuilder 框架。

1. 什么是 Operator？

Kubernetes Operator 是一种基于控制器概念的模式，用于把应用的业务知识封装成自定义的 Kubernetes 控制器，以更高效地管理复杂的 Kubernetes 自定义资源（CRD，Custom Resource Definition）。

Operator 的核心功能

管理 Kubernetes 的 CustomResource（CR）的生命周期。
监控集群中的变化并自动完成操作。
类似人类操作员那样参与应用运行的管理。

2. 开发工具和基础环境

准备工具

Kubernetes 集群： 本地（如 minikube、kind）或远程集群。
安装 Operator 开发工具链：

Kubebuilder: 帮助快速生成 Operator 项目结构和代码。
安装命令：

curl -L -o kubebuilder https://github.com/kubernetes-sigs/kubebuilder/releases/latest/download/kubebuilder_$(uname -s)_$(uname -m).tar.gz
tar -xvf kubebuilder_*.tar.gz
sudo mv kubebuilder /usr/local/bin/

Kustomize: 用于管理 Kubernetes YAML 的工具（kubebuilder 已默认安装）。
Docker: 构建和推送镜像。

编码环境：

安装 go 1.18+ (推荐最新版)。
安装 kubectl。

3. 开发 Operator 的全流程

Step 1: 初始化项目

使用 kubebuilder 初始化项目：

kubebuilder init --domain example.com --repo github.com/username/my-operator

--domain: 定义 CustomResource 的组范围（例如 example.com）。
--repo: 定义生成代码的 Go 模块名（尽量使用 GitHub 地址便于后续管理）。

初始化完成后，项目结构如下：

my-operator/
├── config/           # kustomize 配置文件（CRD、RBAC、Webhook 等）
├── controllers/      # 控制器实现逻辑
├── api/              # CRD 的 API 定义及管理
├── Dockerfile        # 用于构建 Operator 镜像
├── go.mod            # Go 模块依赖
└── main.go           # Operator 的启动代码

Step 2: 创建 CRD 定义

为你的应用资源定义 CustomResource（CRD）。

运行以下命令生成自定义 API 和 Controller：

kubebuilder create api --group batch --version v1alpha1 --kind MyResource

--group: 自定义资源分组。
--version: API 的版本。
--kind: 自定义资源的种类（这里是 MyResource）。

运行后，目录结构会新增部分内容：

api/v1alpha1/myresource_types.go   # CRD 的结构体定义代码
controllers/myresource_controller.go  # MyResource Controller

编辑 API 定义

编辑 api/v1alpha1/myresource_types.go 文件，定义 CRD 的 Spec 和 Status，例如：

type MyResourceSpec struct {
    Replicas int `json:"replicas,omitempty"` // 定义副本数
}

type MyResourceStatus struct {
    AvailableReplicas int `json:"availableReplicas,omitempty"` // 当前可用副本数
}

更新完成后，运行以下命令 生成代码和 CRD YAML 文件：

make generate
make manifests

这会生成 CRD 的 YAML 文件，路径是 config/crd/bases。

Step 3: 编写 Controller

通过 Controller 实现资源的业务逻辑。

编辑 controllers/myresource_controller.go 文件，更新 Reconcile 方法。以下是一个示例：

func (r *MyResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    log := log.FromContext(ctx)

    // 1. 获取 MyResource 对象
    var myResource batchv1alpha1.MyResource
    if err := r.Get(ctx, req.NamespacedName, &myResource); err != nil {
        if apierrors.IsNotFound(err) {
            // 资源被删除，执行清理逻辑
            return ctrl.Result{}, nil
        }
        return ctrl.Result{}, err
    }

    // 2. 根据 MyResource.Spec 实现核心逻辑
    desiredReplicas := myResource.Spec.Replicas
    // 假设我们通过创建 Pod 来控制副本数
    if err := r.ensureReplicaPods(ctx, myResource, desiredReplicas); err != nil {
        log.Error(err, "Failed to ensure replicas")
        return ctrl.Result{}, err
    }

    // 3. 更新 Status
    myResource.Status.AvailableReplicas = desiredReplicas
    if err := r.Status().Update(ctx, &myResource); err != nil {
        log.Error(err, "Failed to update status")
        return ctrl.Result{}, err
    }

    return ctrl.Result{}, nil
}

在此方法内，根据 MyResource 的 Spec 定义，处理各种逻辑（比如创建资源、更新状态等）。

注册控制器

在 main.go 中注册控制器：

import (
    "github.com/username/my-operator/controllers"
)

func main() {
    mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ /* opts */ })
    if err != nil {
        log.Fatal(err)
    }

    if err = (&controllers.MyResourceReconciler{
        Client: mgr.GetClient(),
        Scheme: mgr.GetScheme(),
    }).SetupWithManager(mgr); err != nil {
        log.Fatal(err)
    }

    mgr.Start(ctrl.SetupSignalHandler())
}

Step 4: 测试和部署

本地测试 Operator

在集群中运行 Operator 前，可以本地调试：

make run

此时 Operator 会连接到 Kubernetes 集群（如 kind）。

Docker 构建和推送

将 Operator 打包为容器镜像：

make docker-build docker-push IMG=<your-docker-registry>/my-operator:latest

部署到 Kubernetes

通过 kustomize 应用所有资源：

make deploy IMG=<your-docker-registry>/my-operator:latest

这会完成以下几步：

创建 CRD 定义。
部署 Operator 的 Deployment 和相关 RBAC。

Step 5: 测试 CR 和 Controller

创建自定义资源（CR）：

apiVersion: batch.example.com/v1alpha1
kind: MyResource
metadata:
  name: example-myresource
spec:
  replicas: 3

将其应用到集群：

kubectl apply -f config/samples/batch_v1alpha1_myresource.yaml

使用以下命令验证 Operator 的行为：

kubectl get myresources
kubectl describe myresource example-myresource
kubectl logs -f <operator-pod-name>

4. 最佳实践

模块化代码：

把 Controller 中的逻辑拆分为独立方法，便于维护。
使用 controller-runtime 提供的工具（如 informer、缓存）。

RBAC 权限最小化原则：

编辑 config/rbac 中的权限，使 Operator 仅能访问所需的资源。

集中日志管理：

利用 controller-runtime 的日志功能，记录调试信息。

持续集成/部署（CI/CD）：

使用 GitHub Actions 或其他工具自动化 Operator 的构建和发布。

监控指标：

集成 prometheus，监控 Operator 的性能和行为。

5. 总结

通过上述流程，你可以完成一个基础的 Golang Operator 开发，通过：

定义 CRD。
编写业务逻辑。
编译、测试并部署到 Kubernetes 集群。

框架总结：

Kubebuilder 是最推荐的开发框架。
controller-runtime 提供了简洁高效的控制器开发工具。

随着业务需求增长，可以逐步扩展 Operator 的功能，比如自定义 Webhook、调和复杂应用状态等。

如果觉得文章对你有用，请随意赞赏

Kubernetes Golang

分享：operator开发基本流程

https://www.ztong-techhub.com/archives/Ji5J8kru

作者

张同

发布于

2025-05-08

更新于

2025-05-08

许可协议

CC BY 4.0

分享：operator开发基本流程

1. 什么是 Operator？

Operator 的核心功能

2. 开发工具和基础环境

准备工具

3. 开发 Operator 的全流程

Step 1: 初始化项目

Step 2: 创建 CRD 定义

编辑 API 定义

Step 3: 编写 Controller

注册控制器

Step 4: 测试和部署

本地测试 Operator

Docker 构建和推送

部署到 Kubernetes

Step 5: 测试 CR 和 Controller

4. 最佳实践

5. 总结

作者

发布于

更新于

许可协议

评论