5.3. 基于 Go 的 Operator
5.3.1. 基于 Go 的 Operator 的 operator SDK 指南
Operator SDK 中的 Go 编程语言支持可以利用 Operator SDK 中的 Go 编程语言支持，为 Memcached 构建基于 Go 的 Operator 示例、分布式键值存储并管理其生命周期。
红帽支持的 Operator SDK CLI 工具版本，包括 Operator 项目的相关构建和测试工具已被弃用，计划在以后的 OpenShift Dedicated 发行版本中删除。红帽将在当前发行生命周期中提供对这个功能的程序错误修复和支持，但此功能将不再获得改进，并将在以后的 OpenShift Dedicated 版本中删除。
对于创建新 Operator 项目，不建议使用红帽支持的 Operator SDK 版本。现有 Operator 项目的 Operator 作者可使用 OpenShift Dedicated 4 发布的 Operator SDK CLI 工具版本来维护其项目，并创建针对较新版本的 OpenShift Dedicated 的 Operator 发行版本。
以下与 Operator 项目相关的基础镜像 没有被弃用。这些基础镜像的运行时功能和配置 API 仍然会有程序错误修复和并提供对相关 CVE 的解决方案。
- 基于 Ansible 的 Operator 项目的基础镜像
- 基于 Helm 的 Operator 项目的基础镜像
有关 Operator SDK 不支持的、社区维护版本的信息，请参阅 Operator SDK (Operator Framework)。
通过以下两个 Operator Framework 核心组件来完成此过程：
- Operator SDK
-
operator-sdkCLI 工具和controller-runtime库 API - Operator Lifecycle Manager (OLM)
- 集群中 Operator 的安装、升级和基于角色的访问控制（RBAC）
5.3.1.1. 先决条件
- 已安装 operator SDK CLI
-
已安装 OpenShift CLI (
oc) 4+ - Go 1.21+
-
使用具有
dedicated-admin权限的oc登录到 OpenShift Dedicated 集群 - 要允许集群拉取镜像，推送镜像的存储库必须设置为公共的存储库，或必须配置一个镜像 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), })
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 部署，创建一个。
-
确保部署大小与
MemcachedCR spec 指定的大小相同。 -
使用
memcachedPod 的名称更新MemcachedCR 状态。
下面的小节解释了示例中的控制器如何监视资源以及如何触发协调循环。您可以跳过这些小节来直接进入运行 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.ReadProxyVarsFromEnvhelper 功能添加到协调循环中，并将结果附加到 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 而不是 OpenShift Dedicated 集群，可以使用两个额外的部署选项：
- 作为 Go 程序在集群外本地运行。
- 作为集群的部署运行。
在将基于 Go 的 Operator 作为使用 OLM 的捆绑包运行前，请确保您的项目已更新为使用支持的镜像。
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，则必须更新您的项目以使用支持的镜像在 OpenShift Dedicated 上运行
流程
在 Operator 项目目录中运行以下
make命令来构建和推送 Operator 镜像。在以下步骤中修改IMG参数来引用您可访问的库。您可以获取在存储库站点（如 Quay.io）存储容器的帐户。构建镜像：
$ 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来实现这一目的。如需更多信息，请参阅多个架构。将镜像推送到存储库：
$ make docker-push IMG=<registry>/<user>/<operator_image_name>:<tag>
运行
make bundle命令创建 Operator 捆绑包清单，该命令调用多个命令，其中包括 Operator SDKgenerate 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 捆绑包，该镜像引用一个或多个捆绑包镜像。
构建捆绑包镜像。使用您要推送镜像的 registry、用户命名空间和镜像标签的详情，设置
BUNDLE_IMG：$ make bundle-build BUNDLE_IMG=<registry>/<user>/<bundle_image_name>:<tag>
推送捆绑包镜像：
$ 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 在 OpenShift Dedicated 上默认安装，并作为 Kubernetes 扩展运行，以便您可以在没有任何额外工具的情况下将 Web 控制台和 OpenShift CLI（oc）用于所有 Operator 生命周期管理功能。
Operator Bundle Format 是 Operator SDK 和 OLM 的默认打包方法。您可以使用 Operator SDK 在 OLM 上快速运行捆绑包镜像，以确保它正确运行。
先决条件
- 在开发工作站上安装 operator SDK CLI
- 构建并推送到 registry 的 Operator 捆绑包镜像
-
OLM安装在一个基于 Kubernetes 的集群上（如果使用
apiextensions.k8s.io/v1CRD，则为 v1.16.0 或更新版本，如 OpenShift Dedicated 4） -
使用具有
dedicated-admin权限的账户使用oc登录到集群 - 如果 Operator 基于 Go，则必须更新您的项目以使用支持的镜像在 OpenShift Dedicated 上运行
流程
输入以下命令在集群中运行 Operator：
$ operator-sdk run bundle \1 -n <namespace> \2 <registry>/<user>/<bundle_image_name>:<tag> 3
重要从 OpenShift Dedicated 4.11 开始，
run bundle命令默认支持 Operator 目录的基于文件的目录格式。Operator 目录已弃用的 SQLite 数据库格式仍被支持，但将在以后的发行版本中删除。建议 Operator 作者将其工作流迁移到基于文件的目录格式。这个命令执行以下操作：
- 创建引用捆绑包镜像的索引镜像。索引镜像不透明且具有临时性，但准确反映了如何将捆绑包添加到生产中的目录中。
- 创建指向新索引镜像的目录源，以便 OperatorHub 能够发现 Operator。
-
通过创建一个
OperatorGroup、Subscription、InstallPlan和所有其他所需资源（包括 RBAC），将 Operator 部署到集群中。
5.3.1.7. 创建自定义资源
安装 Operator 后，您可以通过创建一个由 Operator 在集群中提供的自定义资源（CR）来测试它。
先决条件
-
在集群中安装的 Memcached Operator 示例，它提供
MemcachedCR
流程
切换到安装 Operator 的命名空间。例如，如果使用
make deploy命令部署 Operator：$ oc project memcached-operator-system
编辑
config/samples/cache_v1_memcached.yaml上的MemcachedCR 清单示例，使其包含以下规格：apiVersion: cache.example.com/v1 kind: Memcached metadata: name: memcached-sample ... spec: ... size: 3
创建 CR:
$ oc apply -f config/samples/cache_v1_memcached.yaml
确保
MemcachedOperator 为示例 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文件，将MemcachedCR 中的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. 其他资源
5.3.2. 基于 Go 的 Operator 的项目布局
operator-sdk CLI 可为每个 Operator 项目生成或 scaffold 多个 软件包和文件。
红帽支持的 Operator SDK CLI 工具版本，包括 Operator 项目的相关构建和测试工具已被弃用，计划在以后的 OpenShift Dedicated 发行版本中删除。红帽将在当前发行生命周期中提供对这个功能的程序错误修复和支持，但此功能将不再获得改进，并将在以后的 OpenShift Dedicated 版本中删除。
对于创建新 Operator 项目，不建议使用红帽支持的 Operator SDK 版本。现有 Operator 项目的 Operator 作者可使用 OpenShift Dedicated 4 发布的 Operator SDK CLI 工具版本来维护其项目，并创建针对较新版本的 OpenShift Dedicated 的 Operator 发行版本。
以下与 Operator 项目相关的基础镜像 没有被弃用。这些基础镜像的运行时功能和配置 API 仍然会有程序错误修复和并提供对相关 CVE 的解决方案。
- 基于 Ansible 的 Operator 项目的基础镜像
- 基于 Helm 的 Operator 项目的基础镜像
有关 Operator SDK 不支持的、社区维护版本的信息，请参阅 Operator SDK (Operator Framework)。
5.3.2.1. 基于 Go 的项目布局
使用 operator-sdk init 命令生成的基于 Go 的 Operator 项目（默认类型）包含以下文件和目录：
| 文件或目录 | 用途 |
|---|---|
|
|
Operator 的主要程序。这会实例化一个新管理器，它会在 |
|
|
定义 CRD API 的目录树。您必须编辑 |
|
|
控制器的实现。编辑 |
|
| 用于在集群中部署控制器的 Kubernetes 清单，包括 CRD、RBAC 和证书。 |
|
| 用于构建和部署控制器的目标。 |
|
| 容器引擎用来构建 Operator 的说明。 |
|
| Kubernetes 清单用于注册 CRD、设置 RBAC 和将 Operator 部署为部署。 |
5.3.3. 为较新的 Operator SDK 版本更新基于 Go 的 Operator 项目
OpenShift Dedicated 4 支持 Operator SDK 1.36.1。如果已在工作站上安装了 1.31.0 CLI，您可以通过安装最新版本将 CLI 更新至 1.36.1。???
红帽支持的 Operator SDK CLI 工具版本，包括 Operator 项目的相关构建和测试工具已被弃用，计划在以后的 OpenShift Dedicated 发行版本中删除。红帽将在当前发行生命周期中提供对这个功能的程序错误修复和支持，但此功能将不再获得改进，并将在以后的 OpenShift Dedicated 版本中删除。
对于创建新 Operator 项目，不建议使用红帽支持的 Operator SDK 版本。现有 Operator 项目的 Operator 作者可使用 OpenShift Dedicated 4 发布的 Operator SDK CLI 工具版本来维护其项目，并创建针对较新版本的 OpenShift Dedicated 的 Operator 发行版本。
以下与 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 的镜像：在以下文件中找到
kube-rbac-proxy容器的条目：-
config/default/manager_auth_proxy_patch.yaml -
Operator 项目的
bundle/manifests/<operator_name>.clusterserviceversion.yaml，如教程中的memcached-operator.clusterserviceversion.yaml
-
将 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
