5.3. 基于 Go 的 Operator

5.3.1. 基于 Go 的 Operator 的 operator SDK 指南

Operator SDK 中的 Go 编程语言支持可以利用 Operator SDK 中的 Go 编程语言支持，为 Memcached 构建基于 Go 的 Operator 示例、分布式键值存储并管理其生命周期。

重要

红帽支持的 Operator SDK CLI 工具版本，包括 Operator 项目的相关构建和测试工具已被弃用，计划在以后的 Red Hat OpenShift Service on AWS 发行版本中删除。红帽将在当前发行生命周期中提供对这个功能的程序错误修复和支持，但此功能将不再获得改进，并将在以后的 Red Hat OpenShift Service on AWS 发行版本中删除。

对于创建新 Operator 项目，不建议使用红帽支持的 Operator SDK 版本。现有 Operator 项目的 Operator 作者可以使用 Red Hat OpenShift Service on AWS 4 发布的 Operator SDK CLI 工具版本来维护其项目，并创建针对较新版本的 Red Hat OpenShift Service on AWS 的 Operator 发行版本。

以下与 Operator 项目相关的基础镜像没有被弃用。这些基础镜像的运行时功能和配置 API 仍然会有程序错误修复和并提供对相关 CVE 的解决方案。

基于 Ansible 的 Operator 项目的基础镜像
基于 Helm 的 Operator 项目的基础镜像

有关 Operator SDK 不支持的、社区维护版本的信息，请参阅 Operator SDK (Operator Framework)。

通过以下两个 Operator Framework 核心组件来完成此过程：

Operator SDK: operator-sdk CLI 工具和 controller-runtime 库 API
Operator Lifecycle Manager (OLM): 集群中 Operator 的安装、升级和基于角色的访问控制（RBAC）

注意

本教程的内容比 OpenShift Container Platform 文档中的基于 Go 的 Operator 开始使用 Operator SDK 更详细。

5.3.1.1. 前提条件

已安装 operator SDK CLI
已安装 OpenShift CLI (oc) 4+
Go 1.21+
使用具有 dedicated-admin 权限的 oc 登录到 Red Hat OpenShift Service on AWS 集群
要允许集群拉取镜像，推送镜像的存储库必须设置为公共的存储库，或必须配置一个镜像 pull secret

其他资源

5.3.1.2. 创建一个项目

使用 Operator SDK CLI 创建名为 memcached-operator 的 项目。

流程

为项目创建一个目录：

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

进入该目录：
```
$ cd $HOME/projects/memcached-operator
```
激活对 Go 模块的支持：
```
$ export GO111MODULE=on
```
运行 operator-sdk init 命令以初始化项目：
```
$ operator-sdk init \
    --domain=example.com \
    --repo=github.com/example-inc/memcached-operator
```
注意
operator-sdk init 命令默认使用 Go 插件。
operator-sdk init 命令生成一个 go.mod 文件，用于 Go 模块。在创建 $GOPATH/src/ 项目时需要 --repo 标志，因为生成的文件需要有效的模块路径。

5.3.1.2.1. PROJECT 文件

operator-sdk init 命令生成的文件中是一个 Kubebuilder PROJECT 文件。从项目 root 运行的后续 operator-sdk 命令以及 help 输出会读取该文件，并注意到项目的类型为 Go。例如：

domain: example.com
layout:
- go.kubebuilder.io/v3
projectName: memcached-operator
repo: github.com/example-inc/memcached-operator
version: "3"
plugins:
  manifests.sdk.operatorframework.io/v2: {}
  scorecard.sdk.operatorframework.io/v2: {}
  sdk.x-openshift.io/v1: {}

5.3.1.2.2. 关于 Manager

Operator 的主要程序是 main.go 文件，它初始化并运行 Manager。Manager 会自动注册所有自定义资源（CR）API 定义的方案，并设置和运行控制器和 webhook。

Manager 可以限制所有控制器监视资源的命名空间：

mgr, err := ctrl.NewManager(cfg, manager.Options{Namespace: namespace})

默认情况下， Manager 会监视 Operator 的运行命名空间。要监视所有命名空间，您可以将 namespace 选项留空：

mgr, err := ctrl.NewManager(cfg, manager.Options{Namespace: ""})

您还可以使用 MultiNamespacedCacheBuilder 功能来监控特定的命名空间集合：

var namespaces []string 1
mgr, err := ctrl.NewManager(cfg, manager.Options{ 2
   NewCache: cache.MultiNamespacedCacheBuilder(namespaces),
})

1: 命名空间列表。
2: 创建 Cmd 指令以提供共享依赖关系和启动组件。

5.3.1.2.3. 关于多组 API

在创建 API 和控制器前，请考虑您的 Operator 是否需要多个 API 组。本教程涵盖了单个组 API 的默认情况，但要更改项目布局来支持多组 API，您可以运行以下命令：

$ operator-sdk edit --multigroup=true

这个命令更新了 PROJECT 文件，该文件应该类似以下示例：

domain: example.com
layout: go.kubebuilder.io/v3
multigroup: true
...

对于多组项目，API Go 类型文件会在 apis/<group> /<version> / 目录中创建，控制器在 controllers/<group> / 目录中创建。然后会相应地更新 Dockerfile。

其他资源

有关迁移到多组项目的详情，请参阅 Kubebuilder 文档。

5.3.1.3. 创建 API 和控制器

使用 Operator SDK CLI 创建自定义资源定义（CRD）API 和控制器。

流程

运行以下命令创建带有组 cache、版本v1 和种类 Memcached 的 API：

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

提示时，输入 y 来创建资源和控制器：

Create Resource [y/n]
y
Create Controller [y/n]
y

输出示例

Writing scaffold for you to edit...
api/v1/memcached_types.go
controllers/memcached_controller.go
...

此过程会在 api/v1/memcached_types.go 和 controllers/memcached_controller.go 中生成 Memcached 资源 API。

5.3.1.3.1. 定义 API

定义 Memcached 自定义资源（CR）的 API。

流程

修改 api/v1/memcached_types.go 中的 Go 类型定义，使其具有以下 spec 和 status：

// MemcachedSpec defines the desired state of Memcached
type MemcachedSpec struct {
	// +kubebuilder:validation:Minimum=0
	// Size is the size of the memcached deployment
	Size int32 `json:"size"`
}

// MemcachedStatus defines the observed state of Memcached
type MemcachedStatus struct {
	// Nodes are the names of the memcached pods
	Nodes []string `json:"nodes"`
}

为资源类型更新生成的代码：
```
$ make generate
```
提示
在修改了 *_types.go 文件后，您必须运行 make generate 命令来更新该资源类型生成的代码。
以上 Makefile 目标调用 controller-gen 程序来更新 api/v1/zz_generated.deepcopy.go 文件。这样可确保您的 API Go 类型定义实现了 runtime.Object 接口，所有 Kind 类型都必须实现。

5.3.1.3.2. 生成 CRD 清单

在使用 spec 和 status 字段和自定义资源定义（CRD）验证标记定义后，您可以生成 CRD 清单。

流程

运行以下命令以生成和更新 CRD 清单：
```
$ make manifests
```
此 Makefile 目标调用 controller-gen 实用程序在 config/crd/bases/cache.example.com_memcacheds.yaml 文件中生成 CRD 清单。

5.3.1.3.2.1. 关于 OpenAPI 验证

当生成清单时，openAPIV3 模式会添加到 spec.validation 块中的 CRD 清单中。此验证块允许 Kubernetes 在 Memcached 自定义资源（CR）创建或更新时验证其中的属性。

标记或注解可用于为您的 API 配置验证。这些标记始终具有 +kubebuilder:validation 前缀。

其他资源

如需有关在 API 代码中使用标记的更多详细信息，请参阅以下 Kubebuilder 文档：
有关 CRD 中的 OpenAPIv3 验证模式的详情，请参阅 Kubernetes 文档。

5.3.1.4. 实现控制器

在创建新 API 和控制器后，您可以实现控制器逻辑。

流程

在本例中，将生成的控制器文件 controllers/memcached_controller.go 替换为以下示例实现：

例 5.1. memcached_controller.go示例

/*
Copyright 2020.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package controllers

import (
        appsv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/types"
        "reflect"

        "context"

        "github.com/go-logr/logr"
        "k8s.io/apimachinery/pkg/runtime"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        ctrllog "sigs.k8s.io/controller-runtime/pkg/log"

        cachev1 "github.com/example-inc/memcached-operator/api/v1"
)

// MemcachedReconciler reconciles a Memcached object
type MemcachedReconciler struct {
        client.Client
        Log    logr.Logger
        Scheme *runtime.Scheme
}

// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds/finalizers,verbs=update
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;

// Reconcile is part of the main kubernetes reconciliation loop which aims to
// move the current state of the cluster closer to the desired state.
// TODO(user): Modify the Reconcile function to compare the state specified by
// the Memcached object against the actual cluster state, and then
// perform operations to make the cluster state reflect the state specified by
// the user.
//
// For more details, check Reconcile and its Result here:
// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.7.0/pkg/reconcile
func (r *MemcachedReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        //log := r.Log.WithValues("memcached", req.NamespacedName)
        log := ctrllog.FromContext(ctx)
        // Fetch the Memcached instance
        memcached := &cachev1.Memcached{}
        err := r.Get(ctx, req.NamespacedName, memcached)
        if err != nil {
                if errors.IsNotFound(err) {
                        // Request object not found, could have been deleted after reconcile request.
                        // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
                        // Return and don't requeue
                        log.Info("Memcached resource not found. Ignoring since object must be deleted")
                        return ctrl.Result{}, nil
                }
                // Error reading the object - requeue the request.
                log.Error(err, "Failed to get Memcached")
                return ctrl.Result{}, err
        }

        // Check if the deployment already exists, if not create a new one
        found := &appsv1.Deployment{}
        err = r.Get(ctx, types.NamespacedName{Name: memcached.Name, Namespace: memcached.Namespace}, found)
        if err != nil && errors.IsNotFound(err) {
                // Define a new deployment
                dep := r.deploymentForMemcached(memcached)
                log.Info("Creating a new Deployment", "Deployment.Namespace", dep.Namespace, "Deployment.Name", dep.Name)
                err = r.Create(ctx, dep)
                if err != nil {
                        log.Error(err, "Failed to create new Deployment", "Deployment.Namespace", dep.Namespace, "Deployment.Name", dep.Name)
                        return ctrl.Result{}, err
                }
                // Deployment created successfully - return and requeue
                return ctrl.Result{Requeue: true}, nil
        } else if err != nil {
                log.Error(err, "Failed to get Deployment")
                return ctrl.Result{}, err
        }

        // Ensure the deployment size is the same as the spec
        size := memcached.Spec.Size
        if *found.Spec.Replicas != size {
                found.Spec.Replicas = &size
                err = r.Update(ctx, found)
                if err != nil {
                        log.Error(err, "Failed to update Deployment", "Deployment.Namespace", found.Namespace, "Deployment.Name", found.Name)
                        return ctrl.Result{}, err
                }
                // Spec updated - return and requeue
                return ctrl.Result{Requeue: true}, nil
        }

        // Update the Memcached status with the pod names
        // List the pods for this memcached's deployment
        podList := &corev1.PodList{}
        listOpts := []client.ListOption{
                client.InNamespace(memcached.Namespace),
                client.MatchingLabels(labelsForMemcached(memcached.Name)),
        }
        if err = r.List(ctx, podList, listOpts...); err != nil {
                log.Error(err, "Failed to list pods", "Memcached.Namespace", memcached.Namespace, "Memcached.Name", memcached.Name)
                return ctrl.Result{}, err
        }
        podNames := getPodNames(podList.Items)

        // Update status.Nodes if needed
        if !reflect.DeepEqual(podNames, memcached.Status.Nodes) {
                memcached.Status.Nodes = podNames
                err := r.Status().Update(ctx, memcached)
                if err != nil {
                        log.Error(err, "Failed to update Memcached status")
                        return ctrl.Result{}, err
                }
        }

        return ctrl.Result{}, nil
}

// deploymentForMemcached returns a memcached Deployment object
func (r *MemcachedReconciler) deploymentForMemcached(m *cachev1.Memcached) *appsv1.Deployment {
        ls := labelsForMemcached(m.Name)
        replicas := m.Spec.Size

        dep := &appsv1.Deployment{
                ObjectMeta: metav1.ObjectMeta{
                        Name:      m.Name,
                        Namespace: m.Namespace,
                },
                Spec: appsv1.DeploymentSpec{
                        Replicas: &replicas,
                        Selector: &metav1.LabelSelector{
                                MatchLabels: ls,
                        },
                        Template: corev1.PodTemplateSpec{
                                ObjectMeta: metav1.ObjectMeta{
                                        Labels: ls,
                                },
                                Spec: corev1.PodSpec{
                                        Containers: []corev1.Container{{
                                                Image:   "memcached:1.4.36-alpine",
                                                Name:    "memcached",
                                                Command: []string{"memcached", "-m=64", "-o", "modern", "-v"},
                                                Ports: []corev1.ContainerPort{{
                                                        ContainerPort: 11211,
                                                        Name:          "memcached",
                                                }},
                                        }},
                                },
                        },
                },
        }
        // Set Memcached instance as the owner and controller
        ctrl.SetControllerReference(m, dep, r.Scheme)
        return dep
}

// labelsForMemcached returns the labels for selecting the resources
// belonging to the given memcached CR name.
func labelsForMemcached(name string) map[string]string {
        return map[string]string{"app": "memcached", "memcached_cr": name}
}

// getPodNames returns the pod names of the array of pods passed in
func getPodNames(pods []corev1.Pod) []string {
        var podNames []string
        for _, pod := range pods {
                podNames = append(podNames, pod.Name)
        }
        return podNames
}

// SetupWithManager sets up the controller with the Manager.
func (r *MemcachedReconciler) SetupWithManager(mgr ctrl.Manager) error {
        return ctrl.NewControllerManagedBy(mgr).
                For(&cachev1.Memcached{}).
                Owns(&appsv1.Deployment{}).
                Complete(r)
}

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

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

下面的小节解释了示例中的控制器如何监视资源以及如何触发协调循环。您可以跳过这些小节来直接进入运行 Operator。

5.3.1.4.1. 控制器监视的资源

controllers/memcached_controller.go 中的 SetupWithManager() 功能指定如何构建控制器来监视 CR 和其他控制器拥有和管理的资源。

import (
	...
	appsv1 "k8s.io/api/apps/v1"
	...
)

func (r *MemcachedReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&cachev1.Memcached{}).
		Owns(&appsv1.Deployment{}).
		Complete(r)
}

NewControllerManagedBy() 提供了一个控制器构建器，它允许各种控制器配置。

for(&cachev1.Memcached{}) 将 Memcached 类型指定为要监视的主要资源。对于 Memcached 类型的每个 Add、Update 或 Delete 事件，协调循环都会为该 Memcached 对象发送一个协调 Request 参数，其中包括命名空间和名称键。

owns(&appsv1.Deployment{}) 将 Deployment 类型指定为要监视的辅助资源。对于 Deployment 类型的每个 Add、Update 或 Delete 事件，事件处理程序会将每个事件映射到部署所有者的协调请求。在本例中，所有者是创建部署的 Memcached 对象。

5.3.1.4.2. 控制器配置

您可以不同的配置来初始化控制器。例如：

使用 MaxConcurrentReconciles 选项设置控制器的并发协调的最大数量，其默认值为 1：

func (r *MemcachedReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&cachev1.Memcached{}).
        Owns(&appsv1.Deployment{}).
        WithOptions(controller.Options{
            MaxConcurrentReconciles: 2,
        }).
        Complete(r)
}

使用 predicates 过滤监视事件。
选择 EventHandler 类型来更改监视事件转换的方式，以协调协调循环的请求。对于比主和从属资源更复杂的 Operator 关系，您可以使用 EnqueueRequestsFromMapFunc 处理程序将监控事件转换为一组任意协调请求。

有关这些配置和其他配置的详情，请参阅上游 Builder 和 Controller GoDocs。

5.3.1.4.3. 协调循环

每个控制器都有一个协调器对象，它带有实现了协调循环的 Reconcile() 方法。协调循环通过 Request 参数传递，该参数是从缓存中查找主资源对象 Memcached 的命名空间和名称键：

import (
	ctrl "sigs.k8s.io/controller-runtime"

	cachev1 "github.com/example-inc/memcached-operator/api/v1"
	...
)

func (r *MemcachedReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
  // Lookup the Memcached instance for this reconcile request
  memcached := &cachev1.Memcached{}
  err := r.Get(ctx, req.NamespacedName, memcached)
  ...
}

根据返回值、结果和错误，请求可能会重新排序，协调循环可能会再次触发：

// Reconcile successful - don't requeue
return ctrl.Result{}, nil
// Reconcile failed due to error - requeue
return ctrl.Result{}, err
// Requeue for any reason other than an error
return ctrl.Result{Requeue: true}, nil

您可以将 Result.RequeueAfter 设置为在宽限期后重新排序请求：

import "time"

// Reconcile for any reason other than an error after 5 seconds
return ctrl.Result{RequeueAfter: time.Second*5}, nil

注意

您可以返回带有 RequeueAfter 设置的 Result 来定期协调一个 CR。

有关协调器、客户端并与资源事件交互的更多信息，请参阅 Controller Runtime Client API 文档。

5.3.1.4.4. 权限和 RBAC 清单

控制器需要特定的 RBAC 权限与它管理的资源交互。它们通过 RBAC 标记来指定，如下所示：

// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=cache.example.com,resources=memcacheds/finalizers,verbs=update
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;

func (r *MemcachedReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
  ...
}

config/rbac/role.yaml 中的 ClusterRole 对象清单通过在每次运行 manifests 命令时使用 controller-gen 实用程序的以前的标记生成。

5.3.1.5. 启用代理支持

Operator 作者可开发支持网络代理的 Operator。具有 dedicated-admin 角色的管理员配置对 Operator Lifecycle Manager (OLM)处理的环境变量的代理支持。要支持代理集群，Operator 必须检查以下标准代理变量的环境，并将值传递给 Operands：

HTTP_PROXY
HTTPS_PROXY
NO_PROXY

注意

本教程使用 HTTP_PROXY 作为示例环境变量。

前提条件

启用了集群范围的出口代理的集群。

流程

编辑 controllers/memcached_controller.go 文件，使其包含以下项：

从 operator-lib 库导入 proxy 软件包：

import (
  ...
   "github.com/operator-framework/operator-lib/proxy"
)

将 proxy.ReadProxyVarsFromEnv helper 功能添加到协调循环中，并将结果附加到 Operand 环境：

for i, container := range dep.Spec.Template.Spec.Containers {
		dep.Spec.Template.Spec.Containers[i].Env = append(container.Env, proxy.ReadProxyVarsFromEnv()...)
}
...

通过在 config/manager/manager.yaml 文件中添加以下内容来设置 Operator 部署上的环境变量：

containers:
 - args:
   - --leader-elect
   - --leader-election-id=ansible-proxy-demo
   image: controller:latest
   name: manager
   env:
     - name: "HTTP_PROXY"
       value: "http_proxy_test"

5.3.1.6. 运行 Operator

要构建并运行 Operator，请使用 Operator SDK CLI 捆绑 Operator，然后使用 Operator Lifecycle Manager (OLM)部署到集群中。

注意

如果要在 OpenShift Container Platform 集群上部署 Operator 而不是 Red Hat OpenShift Service on AWS 集群，则有两个部署选项：

作为 Go 程序在集群外本地运行。
作为集群的部署运行。

注意

在将基于 Go 的 Operator 作为使用 OLM 的捆绑包运行前，请确保您的项目已更新为使用支持的镜像。

其他资源

在集群外本地运行 (OpenShift Container Platform 文档)
作为集群的部署运行 (OpenShift Container Platform 文档)

5.3.1.6.1. 捆绑 Operator 并使用 Operator Lifecycle Manager 进行部署

5.3.1.6.1.1. 捆绑 Operator

Operator 捆绑包格式是 Operator SDK 和 Operator Lifecycle Manager（OLM）的默认打包方法。您可以使用 Operator SDK 来构建和推送 Operator 项目作为捆绑包镜像，使 Operator 可供 OLM 使用。

前提条件

在开发工作站上安装 operator SDK CLI
已安装 OpenShift CLI (oc) v4+
使用 Operator SDK 初始化 operator 项目
如果 Operator 基于 Go，则必须更新您的项目以使用支持的镜像在 Red Hat OpenShift Service on AWS 上运行

流程

在 Operator 项目目录中运行以下 make 命令来构建和推送 Operator 镜像。在以下步骤中修改 IMG 参数来引用您可访问的库。您可以获取在存储库站点（如 Quay.io）存储容器的帐户。
1. 构建镜像：
```
$ make docker-build IMG=<registry>/<user>/<operator_image_name>:<tag>
```
  注意
  由 SDK 为 Operator 生成的 Dockerfile 需要为 go build 明确引用 GOARCH=amd64。这可以在非 AMD64 构架中使用 GOARCH=$TARGETARCH。Docker 自动将环境变量设置为 -platform 指定的值。对于 Buildah，需要使用 -build-arg 来实现这一目的。如需更多信息，请参阅多个架构。
2. 将镜像推送到存储库：
```
$ make docker-push IMG=<registry>/<user>/<operator_image_name>:<tag>
```
运行 make bundle 命令创建 Operator 捆绑包清单，该命令调用多个命令，其中包括 Operator SDK generate bundle 和 bundle validate 子命令：
```
$ make bundle IMG=<registry>/<user>/<operator_image_name>:<tag>
```
Operator 的捆绑包清单描述了如何显示、创建和管理应用程序。make bundle 命令在 Operator 项目中创建以下文件和目录：
- 包含 ClusterServiceVersion 对象的捆绑包清单目录，名为 bundle/manifests
- 名为 bundle/metadata 的捆绑包元数据目录
- config/crd 目录中的所有自定义资源定义（CRD）
- 一个 Dockerfile bundle.Dockerfile
然后，使用 operator-sdk bundle validate 自动验证这些文件，以确保磁盘上的捆绑包的格式是正确的。
运行以下命令来构建和推送捆绑包镜像。OLM 使用索引镜像来消耗 Operator 捆绑包，该镜像引用一个或多个捆绑包镜像。
1. 构建捆绑包镜像。使用您要推送镜像的 registry、用户命名空间和镜像标签的详情，设置 BUNDLE_IMG：
```
$ make bundle-build BUNDLE_IMG=<registry>/<user>/<bundle_image_name>:<tag>
```
2. 推送捆绑包镜像：
```
$ docker push <registry>/<user>/<bundle_image_name>:<tag>
```

5.3.1.6.1.2. 使用 Operator Lifecycle Manager 部署 Operator

Operator Lifecycle Manager（OLM）可帮助您在 Kubernetes 集群中安装、更新和管理 Operator 及其相关服务的生命周期。OLM 默认安装在 Red Hat OpenShift Service on AWS 上，并作为 Kubernetes 扩展运行，以便您可以在没有任何额外工具的情况下对所有 Operator 生命周期管理功能使用 Web 控制台和 OpenShift CLI (oc)。

Operator Bundle Format 是 Operator SDK 和 OLM 的默认打包方法。您可以使用 Operator SDK 在 OLM 上快速运行捆绑包镜像，以确保它正确运行。

前提条件

在开发工作站上安装 operator SDK CLI
构建并推送到 registry 的 Operator 捆绑包镜像
OLM 安装在一个基于 Kubernetes 的集群上（如果使用 apiextensions.k8s.io/v1 CRD，则为 v1.16.0 或更新版本，如 Red Hat OpenShift Service on AWS 4）
使用具有 dedicated-admin 权限的账户使用 oc 登录到集群
如果 Operator 基于 Go，则必须更新您的项目以使用支持的镜像在 Red Hat OpenShift Service on AWS 上运行

流程

输入以下命令在集群中运行 Operator：
```
$ operator-sdk run bundle \1
    -n <namespace> \2
    <registry>/<user>/<bundle_image_name>:<tag> 3
```
1
run bundle 命令创建基于文件的有效目录，并使用 OLM 在集群中安装 Operator 捆绑包。
2
可选：默认情况下，命令会在 ~/.kube/config 文件中当前活跃的项目中安装 Operator。您可以添加 -n 标志来为安装设置不同的命名空间范围。
3
如果没有指定镜像，该命令使用 quay.io/operator-framework/opm:latest 作为默认索引镜像。如果指定了镜像，该命令会使用捆绑包镜像本身作为索引镜像。
重要
从 Red Hat OpenShift Service on AWS 4.11 开始，run bundle 命令默认支持 Operator 目录的基于文件的目录格式。Operator 目录已弃用的 SQLite 数据库格式仍被支持，但将在以后的发行版本中删除。建议 Operator 作者将其工作流迁移到基于文件的目录格式。
这个命令执行以下操作：
- 创建引用捆绑包镜像的索引镜像。索引镜像不透明且具有临时性，但准确反映了如何将捆绑包添加到生产中的目录中。
- 创建指向新索引镜像的目录源，以便 OperatorHub 能够发现 Operator。
- 通过创建一个 OperatorGroup、Subscription、InstallPlan 和所有其他所需资源（包括 RBAC），将 Operator 部署到集群中。

5.3.1.7. 创建自定义资源

安装 Operator 后，您可以通过创建一个由 Operator 在集群中提供的自定义资源（CR）来测试它。

先决条件

在集群中安装的 Memcached Operator 示例，它提供 Memcached CR

流程

切换到安装 Operator 的命名空间。例如，如果使用 make deploy 命令部署 Operator：
```
$ oc project memcached-operator-system
```

编辑 config/samples/cache_v1_memcached.yaml 上的 Memcached CR 清单示例，使其包含以下规格：

apiVersion: cache.example.com/v1
kind: Memcached
metadata:
  name: memcached-sample
...
spec:
...
  size: 3

创建 CR:

$ oc apply -f config/samples/cache_v1_memcached.yaml

确保 Memcached Operator 为示例 CR 创建部署，其大小正确：

$ oc get deployments

输出示例

NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
memcached-operator-controller-manager   1/1     1            1           8m
memcached-sample                        3/3     3            3           1m

检查 pod 和 CR 状态，以确认其状态是否使用 Memcached pod 名称更新。

检查 pod:

$ oc get pods

输出示例

NAME                                  READY     STATUS    RESTARTS   AGE
memcached-sample-6fd7c98d8-7dqdr      1/1       Running   0          1m
memcached-sample-6fd7c98d8-g5k7v      1/1       Running   0          1m
memcached-sample-6fd7c98d8-m7vn7      1/1       Running   0          1m

检查 CR 状态：

$ oc get memcached/memcached-sample -o yaml

输出示例

apiVersion: cache.example.com/v1
kind: Memcached
metadata:
...
  name: memcached-sample
...
spec:
  size: 3
status:
  nodes:
  - memcached-sample-6fd7c98d8-7dqdr
  - memcached-sample-6fd7c98d8-g5k7v
  - memcached-sample-6fd7c98d8-m7vn7

更新部署大小。

更新 config/samples/cache_v1_memcached.yaml 文件，将 Memcached CR 中的 spec.size 字段从 3 改为 5：
```
$ oc patch memcached memcached-sample \
    -p '{"spec":{"size": 5}}' \
    --type=merge
```

确认 Operator 已更改部署大小：

$ oc get deployments

输出示例

NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
memcached-operator-controller-manager   1/1     1            1           10m
memcached-sample                        5/5     5            5           3m

运行以下命令来删除 CR：

$ oc delete -f config/samples/cache_v1_memcached.yaml

清理本教程中创建的资源。
- 如果使用 make deploy 命令来测试 Operator，请运行以下命令：
```
$ make undeploy
```
- 如果使用 operator-sdk run bundle 命令来测试 Operator，请运行以下命令：
```
$ operator-sdk cleanup <project_name>
```

5.3.1.8. 其他资源

请参阅基于 Go 的 Operator 的项目布局，以了解 Operator SDK 创建的目录结构。
如果配置了集群范围的出口代理，则具有 dedicated- admin 角色的管理员可以覆盖代理设置，或为 Operator Lifecycle Manager (OLM)上运行的特定 Operator 注入自定义 CA 证书。

5.3.2. 基于 Go 的 Operator 的项目布局

operator-sdk CLI 可为每个 Operator 项目生成或 scaffold 多个软件包和文件。

重要

以下与 Operator 项目相关的基础镜像没有被弃用。这些基础镜像的运行时功能和配置 API 仍然会有程序错误修复和并提供对相关 CVE 的解决方案。

基于 Ansible 的 Operator 项目的基础镜像
基于 Helm 的 Operator 项目的基础镜像

有关 Operator SDK 不支持的、社区维护版本的信息，请参阅 Operator SDK (Operator Framework)。

5.3.2.1. 基于 Go 的项目布局

使用 operator-sdk init 命令生成的基于 Go 的 Operator 项目（默认类型）包含以下文件和目录：

文件或目录	用途
`main.go`	Operator 的主要程序。这会实例化一个新管理器，它会在 `apis/` 目录中注册所有自定义资源定义（CRD），并启动 `controllers/` 目录中的所有控制器。
`apis/`	定义 CRD API 的目录树。您必须编辑 `apis/<version> /<kind>_types.go` 文件，为每个资源类型定义 API，并在控制器中导入这些软件包以监视这些资源类型。
`controllers/`	控制器的实现。编辑 `controller/<kind>_controller.go` 文件，以定义控制器处理指定种类资源类型的协调逻辑。
`config/`	用于在集群中部署控制器的 Kubernetes 清单，包括 CRD、RBAC 和证书。
`Makefile`	用于构建和部署控制器的目标。
`Docker`	容器引擎用来构建 Operator 的说明。
`manifests/`	Kubernetes 清单用于注册 CRD、设置 RBAC 和将 Operator 部署为部署。

5.3.3. 为较新的 Operator SDK 版本更新基于 Go 的 Operator 项目

Red Hat OpenShift Service on AWS 4 支持 Operator SDK 1.36.1。如果已在工作站上安装了 1.31.0 CLI，您可以通过安装最新版本将 CLI 更新至 1.36.1。???

重要

以下与 Operator 项目相关的基础镜像没有被弃用。这些基础镜像的运行时功能和配置 API 仍然会有程序错误修复和并提供对相关 CVE 的解决方案。

基于 Ansible 的 Operator 项目的基础镜像
基于 Helm 的 Operator 项目的基础镜像

有关 Operator SDK 不支持的、社区维护版本的信息，请参阅 Operator SDK (Operator Framework)。

但是，要确保现有 Operator 项目保持与 Operator SDK 1.36.1 的兼容性，需要执行更新的相关步骤才能解决从 1.31.0 以来引入的相关破坏更改。您必须在之前使用 1.31.0 创建或维护的任何 Operator 项目中手动执行更新步骤。

5.3.3.1. 为 Operator SDK 1.36.1 更新基于 Go 的 Operator 项目

以下流程更新了基于 Go 的 Operator 项目，以便与 1.36.1 兼容。

前提条件

已安装 operator SDK 1.36.1
使用 Operator SDK 1.31.0 创建或维护的 Operator 项目

流程

编辑 Operator 项目的 Makefile，将 Operator SDK 版本更新至 v1.36.1-ocp，如下例所示：

Makefile 示例

# Set the Operator SDK version to use. By default, what is installed on the system is used.
# This is useful for CI or a project to utilize a specific version of the operator-sdk toolkit.
OPERATOR_SDK_VERSION ?= v1.36.1-ocp

更新 kube-rbac-proxy 容器，以使用基于 Red Hat Enterprise Linux (RHEL) 9 的镜像：
1. 在以下文件中找到 kube-rbac-proxy 容器的条目：
  - config/default/manager_auth_proxy_patch.yaml
  - Operator 项目的 bundle/manifests/<operator_name>.clusterserviceversion.yaml，如教程中的 memcached-operator.clusterserviceversion.yaml
2. 将 pull spec 中的镜像名称从 ose-kube-rbac-proxy 更新至 ose-kube-rbac-proxy-rhel9，并将标签更新为 v4 ：
  ose-kube-rbac-proxy-rhel9 使用 v4 镜像标签拉取 spec 示例
```
# ...
      containers:
      - name: kube-rbac-proxy
        image: registry.redhat.io/openshift4/ose-kube-rbac-proxy-rhel9:v4
# ...
```
go/v4 插件现在稳定，是构建基于 Go 的 Operator 时使用的默认版本。从 Golang v2 和 v3 插件转换到新的 Golang v4 插件引入了大量更改。此迁移旨在增强您的项目的功能和兼容性，反映 Golang 开发不断演变的环境。
有关这些更改后的原因的更多信息，请参阅 Kubebuilder 文档中的 go/v3 和 go/v4。
要全面了解 v4 插件格式和详细的迁移步骤，请参阅从 go/v3 迁移到 go/v4，方法是在 Kubebuilder 文档中手动更新文件。
kustomize/v2 插件现在稳定，在使用 go/v4,ansible/v1,helm/v1, 和 hybrid/v1-alpha 插件时，插件链中使用的默认版本。有关此默认构建的更多信息，请参阅 Kubebuilder 文档中的 Kustomize v2。

如果您的 Operator 项目使用多平台或多架构，构建，将现有 docker-buildx 目标替换为项目 Makefile 中的以下定义：

Makefile 示例

docker-buildx:
## Build and push the Docker image for the manager for multi-platform support
	- docker buildx create --name project-v3-builder
	docker buildx use project-v3-builder
	- docker buildx build --push --platform=$(PLATFORMS) --tag ${IMG} -f Dockerfile .
	- docker buildx rm project-v3-builder

您必须将 Operator 项目中的 Kubernetes 版本升级到使用 1.29。必须在项目结构、Makefile 和 go.mod 文件中进行以下更改。

重要

Kubebuilder 弃用 go/v3 插件，因此 Operator SDK 也会在以后的版本中迁移到 go/v4。

更新您的 go.mod 文件以升级您的依赖项：

k8s.io/api v0.29.2
k8s.io/apimachinery v0.29.2
k8s.io/client-go v0.29.2
sigs.k8s.io/controller-runtime v0.17.3

运行以下命令来下载升级的依赖项：
```
$ go mod tidy
```

现在，您可以生成一个包含使用 Kustomize 构建的所有资源的文件，这是在没有依赖项的情况下安装此项目所必需的。通过进行以下更改来更新 Makefile：

+ .PHONY: build-installer
+   build-installer: manifests generate kustomize ## Generate a consolidated YAML with CRDs and deployment.
+   	mkdir -p dist
+   	cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG}
+   	$(KUSTOMIZE) build config/default > dist/install.yaml

通过进行以下更改，更新 Makefile 中的 ENVTEST_K8S_VERSION 变量：
```
- ENVTEST_K8S_VERSION = 1.28.3
+ ENVTEST_K8S_VERSION = 1.29.0
```

从 Makefile 中删除以下部分：

- GOLANGCI_LINT = $(shell pwd)/bin/golangci-lint
- GOLANGCI_LINT_VERSION ?= v1.54.2
- golangci-lint:
- 	@[ -f $(GOLANGCI_LINT) ] || { \
- 	set -e ;\
- 	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(shell dirname $(GOLANGCI_LINT)) $(GOLANGCI_LINT_VERSION) ;\
- 	}

通过进行以下更改来更新 Makefile：

例 5.2. Makefile 更改

- ## Tool Binaries
- KUBECTL ?= kubectl
- KUSTOMIZE ?= $(LOCALBIN)/kustomize
- CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen
- ENVTEST ?= $(LOCALBIN)/setup-envtest
-
- ## Tool Versions
- KUSTOMIZE_VERSION ?= v5.2.1
- CONTROLLER_TOOLS_VERSION ?= v0.13.0
-
- .PHONY: kustomize
- kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary. If wrong version is installed, it will be removed before downloading.
- $(KUSTOMIZE): $(LOCALBIN)
-   @if test -x $(LOCALBIN)/kustomize && ! $(LOCALBIN)/kustomize version | grep -q $(KUSTOMIZE_VERSION); then \
-   echo "$(LOCALBIN)/kustomize version is not expected $(KUSTOMIZE_VERSION). Removing it before installing."; \
-   rm -rf $(LOCALBIN)/kustomize; \
-   fi
-   test -s $(LOCALBIN)/kustomize || GOBIN=$(LOCALBIN) GO111MODULE=on go install sigs.k8s.io/kustomize/kustomize/v5@$(KUSTOMIZE_VERSION)
-
- .PHONY: controller-gen
- controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary. If wrong version is installed, it will be overwritten.
- $(CONTROLLER_GEN): $(LOCALBIN)
-   test -s $(LOCALBIN)/controller-gen && $(LOCALBIN)/controller-gen --version | grep -q $(CONTROLLER_TOOLS_VERSION) || \
-   GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_TOOLS_VERSION)
-
- .PHONY: envtest
- envtest: $(ENVTEST) ## Download envtest-setup locally if necessary.
- $(ENVTEST): $(LOCALBIN)
-   test -s $(LOCALBIN)/setup-envtest || GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-runtime/tools/setup-envtest@latest
+ ## Tool Binaries
+ KUBECTL ?= kubectl
+ KUSTOMIZE ?= $(LOCALBIN)/kustomize-$(KUSTOMIZE_VERSION)
+ CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen-$(CONTROLLER_TOOLS_VERSION)
+ ENVTEST ?= $(LOCALBIN)/setup-envtest-$(ENVTEST_VERSION)
+ GOLANGCI_LINT = $(LOCALBIN)/golangci-lint-$(GOLANGCI_LINT_VERSION)
+
+ ## Tool Versions
+ KUSTOMIZE_VERSION ?= v5.3.0
+ CONTROLLER_TOOLS_VERSION ?= v0.14.0
+ ENVTEST_VERSION ?= release-0.17
+ GOLANGCI_LINT_VERSION ?= v1.57.2
+
+ .PHONY: kustomize
+ kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary.
+ $(KUSTOMIZE): $(LOCALBIN)
+ 	$(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION))
+
+ .PHONY: controller-gen
+ controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary.
+ $(CONTROLLER_GEN): $(LOCALBIN)
+ 	$(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION))
+
+ .PHONY: envtest
+ envtest: $(ENVTEST) ## Download setup-envtest locally if necessary.
+ $(ENVTEST): $(LOCALBIN)
+ 	$(call go-install-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest,$(ENVTEST_VERSION))
+
+ .PHONY: golangci-lint
+ golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary.
+ $(GOLANGCI_LINT): $(LOCALBIN)
+ 	$(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,${GOLANGCI_LINT_VERSION})
+
+ # go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist
+ # $1 - target path with name of binary (ideally with version)
+ # $2 - package url which can be installed
+ # $3 - specific version of package
+ define go-install-tool
+ @[ -f $(1) ] || { \
+ set -e; \
+ package=$(2)@$(3) ;\
+ echo "Downloading $${package}" ;\
+ GOBIN=$(LOCALBIN) go install $${package} ;\
+ mv "$$(echo "$(1)" | sed "s/-$(3)$$//")" $(1) ;\
+ }
+ endef

5.3.3.2. 其他资源

为 Operator SDK 1.31.0 升级项目 (Red Hat OpenShift Service on AWS 4.16)
将软件包清单项目迁移到捆绑包格式

5.3. 基于 Go 的 Operator

5.3.1. 基于 Go 的 Operator 的 operator SDK 指南

5.3.1.1. 前提条件

5.3.1.2. 创建一个项目

5.3.1.2.1. PROJECT 文件

5.3.1.2.2. 关于 Manager

5.3.1.2.3. 关于多组 API

5.3.1.3. 创建 API 和控制器

5.3.1.3.1. 定义 API

5.3.1.3.2. 生成 CRD 清单

5.3.1.3.2.1. 关于 OpenAPI 验证

5.3.1.4. 实现控制器

5.3.1.4.1. 控制器监视的资源

5.3.1.4.2. 控制器配置

5.3.1.4.3. 协调循环

5.3.1.4.4. 权限和 RBAC 清单

5.3.1.5. 启用代理支持

5.3.1.6. 运行 Operator

5.3.1.6.1. 捆绑 Operator 并使用 Operator Lifecycle Manager 进行部署

5.3.1.6.1.1. 捆绑 Operator

5.3.1.6.1.2. 使用 Operator Lifecycle Manager 部署 Operator

5.3.1.7. 创建自定义资源

5.3.1.8. 其他资源

5.3.2. 基于 Go 的 Operator 的项目布局

5.3.2.1. 基于 Go 的项目布局

5.3.3. 为较新的 Operator SDK 版本更新基于 Go 的 Operator 项目

5.3.3.1. 为 Operator SDK 1.36.1 更新基于 Go 的 Operator 项目

5.3.3.2. 其他资源

学习

尝试、购买和销售

社区

关于红帽文档

让开源更具包容性

關於紅帽

Red Hat legal and privacy links

Red Hat legal and privacy links