我们知道了如何使用 code-generator 来进行代码自动生成，通过代码自动生成可以帮我们自动生成 CRD 资源对象客户端访问的 ClientSet、Informer、Lister 等工具包，接下来我们来了解下如何编写一个自定义的控制器。
CRD 定义
这里我们来针对前面课程中介绍的 CronTab 自定义资源对象编写一个自定义的控制器，对应的资源清单文件如下所示：
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: crontabs.stable.example.com
spec:
group: stable.example.com
versions:
- name: v1beta1
served: true
storage: true
schema:
openAPIV3Schema:
description: Define CronTab YAML Spec
type: object
properties:
spec:
type: object
properties:
cronSpec:
type: string
image:
type: string
replicas:
type: integer
scope: Namespaced
names:
kind: CronTab
plural: crontabs
singular: crontab
shortNames:
- ct我们需要针对上面的规范来定义资源结构，首先初始化项目：
$ mkdir -p github.com/guilinonline/controller-demo && cd github.com/guilinonline/controller-demo
# 初始化项目
$ go mod init github.com/guilinonline/controller-demo
go: creating new go.mod: module github.com/guilinonline/controller-demo
# 获取依赖
$ go get k8s.io/apimachinery@v0.17.9
$ go get -d k8s.io/code-generator@v0.17.9
$ go get k8s.io/client-go@v0.17.9然后初始化 CRD 资源类型，建立好自己的 CRD 结构体，然后使用code-generator 生成客户端代码：
$ mkdir -p pkg/apis/stable/v1beta1在该文件夹中新建 doc.go 文件，内容如下所示：
// +k8s:deepcopy-gen=package
// +groupName=stable.example.com
package v1beta1根据 CRD 的规范定义，这里我们定义的 group 为 stable.example.com，版本为 v1beta1 ，在顶部添加了一个代码自动生成的 deepcopy-gen 的 tag，为整个包中的类型生成深拷贝方法。
然后就是非常重要的资源对象的结构体定义，新建 type.go 文件，内容如下所示：
package v1beta1
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// +genclient
// +genclient:noStatus
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// 根据 CRD 定义 CronTab 结构体
type CronTab struct {
metav1.TypeMeta `json:",inline"`
// +optional
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec CronTabSpec `json:"spec"`
}
// +k8s:deepcopy-gen=false
type CronTabSpec struct {
CronSpec string `json:"cronSpec"`
Image string `json:"image"`
Replicas int `json:"replicas"`
}
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// CronTab 资源列表
type CronTabList struct {
metav1.TypeMeta `json:",inline"`
// 标准的 list metadata
// +optional
metav1.ListMeta `json:"metadata,omitempty"`
Items []CronTab `json:"items"`
}然后可以参考系统内置的资源对象，还需要提供 AddToScheme 与 Resource 两个变量供 client 注册，新建 register.go 文件，内容如下所示：
package v1beta1
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
// GroupName is the group name use in this package
const GroupName = "stable.example.com"
// 注册自己的自定义资源
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}
// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
return SchemeGroupVersion.WithResource(resource).GroupResource()
}
var (
// SchemeBuilder initializes a scheme builder
SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
// AddToScheme is a global function that registers this API group & version to a scheme
AddToScheme = SchemeBuilder.AddToScheme
)
// Adds the list of known types to Scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
// 添加 CronTab 与 CronTabList 这两个资源到 scheme
scheme.AddKnownTypes(SchemeGroupVersion,
&CronTab{},
&CronTabList{},
)
metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
return nil
}最终的项目结构如下所示：
$ tree .
.
├── go.mod
├── go.sum
└── pkg
└── apis
└── stable
└── v1beta1
├── doc.go
├── register.go
└── types.go
4 directories, 5 files生成代码
上面我们准备好资源的 API 资源类型后，就可以使用开始生成 CRD 资源的客户端使用的相关代码了。
首先创建生成代码的脚本，下面这些脚本均来源于 sample-controller 仓库提供的示例：
$ mkdir hack && cd hack在该目录下面新建 tools.go 文件，添加 code-generator 依赖，因为在没有代码使用 code-generator 时，go module 默认不会为我们依赖此包。文件内容如下所示：
// +build tools
// 建立 tools.go 来依赖 code-generator
// 因为在没有代码使用 code-generator 时，go module 默认不会为我们依赖此包.
package tools
import _ "k8s.io/code-generator"然后新建 update-codegen.sh 脚本，用来配置代码生成的脚本：
#!/usr/bin/env bash
set -o errexit
set -o nounset
set -o pipefail
SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
CODEGEN_PKG=${CODEGEN_PKG:-$(cd "${SCRIPT_ROOT}"; ls -d -1 ./vendor/k8s.io/code-generator 2>/dev/null || echo ../code-generator)}
bash "${CODEGEN_PKG}"/generate-groups.sh "deepcopy,client,informer,lister" \
github.com/guilinonline/controller-demo/pkg/client github.com/guilinonline/controller-demo/pkg/apis \
stable:v1beta1 \
--output-base "${SCRIPT_ROOT}"/../../.. \
--go-header-file "${SCRIPT_ROOT}"/hack/boilerplate.go.txt
# To use your own boilerplate text append:
# --go-header-file "${SCRIPT_ROOT}"/hack/custom-boilerplate.go.txt同样还有上节课提到的 verify-codegen.sh 脚本，用来校验生成的代码是否是最新的：
#!/usr/bin/env bash
set -o errexit
set -o nounset
set -o pipefail
SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
DIFFROOT="${SCRIPT_ROOT}/pkg"
TMP_DIFFROOT="${SCRIPT_ROOT}/_tmp/pkg"
_tmp="${SCRIPT_ROOT}/_tmp"
cleanup() {
rm -rf "${_tmp}"
}
trap "cleanup" EXIT SIGINT
cleanup
mkdir -p "${TMP_DIFFROOT}"
cp -a "${DIFFROOT}"/* "${TMP_DIFFROOT}"
"${SCRIPT_ROOT}/hack/update-codegen.sh"
echo "diffing ${DIFFROOT} against freshly generated codegen"
ret=0
diff -Naupr "${DIFFROOT}" "${TMP_DIFFROOT}" || ret=$?
cp -a "${TMP_DIFFROOT}"/* "${DIFFROOT}"
if [[ $ret -eq 0 ]]
then
echo "${DIFFROOT} up to date."
else
echo "${DIFFROOT} is out of date. Please run hack/update-codegen.sh"
exit 1
fi还有一个为生成的代码文件添加头部内容的 boilerplate.go.txt 文件，内容如下所示，其实就是为每个生成的代码文件头部添加上下面的开源协议声明：
/*
Copyright The Kubernetes Authors.
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.
*/接下来我们就可以来执行代码生成的脚本了，首先将依赖包放置到 vendor 目录中去：
$ go mod vendor然后执行脚本生成代码：
$ chmod +x ./hack/update-codegen.sh
$ ./hack/update-codegen.sh
Generating deepcopy funcs
Generating clientset for stable:v1beta1 at github.com/guilinonline/controller-demo/pkg/client/clientset
Generating listers for stable:v1beta1 at github.com/guilinonline/controller-demo/pkg/client/listers
Generating informers for stable:v1beta1 at github.com/guilinonline/controller-demo/pkg/client/informers代码生成后，整个项目的 pkg 包变成了下面的样子：
$ tree pkg
pkg
├── apis
│ └── stable
│ └── v1beta1
│ ├── doc.go
│ ├── register.go
│ ├── types.go
│ └── zz_generated.deepcopy.go
└── client
├── clientset
│ └── versioned
│ ├── clientset.go
│ ├── doc.go
│ ├── fake
│ │ ├── clientset_generated.go
│ │ ├── doc.go
│ │ └── register.go
│ ├── scheme
│ │ ├── doc.go
│ │ └── register.go
│ └── typed
│ └── stable
│ └── v1beta1
│ ├── crontab.go
│ ├── doc.go
│ ├── fake
│ │ ├── doc.go
│ │ ├── fake_crontab.go
│ │ └── fake_stable_client.go
│ ├── generated_expansion.go
│ └── stable_client.go
├── informers
│ └── externalversions
│ ├── factory.go
│ ├── generic.go
│ ├── internalinterfaces
│ │ └── factory_interfaces.go
│ └── stable
│ ├── interface.go
│ └── v1beta1
│ ├── crontab.go
│ └── interface.go
└── listers
└── stable
└── v1beta1
├── crontab.go
└── expansion_generated.go
20 directories, 26 files仔细观察可以发现 pkg/apis/stable/v1beta1 目录下面多了一个zz_generated.deepcopy.go 文件,在 pkg/client 文件夹下生成了 clientset和 informers 和 listers 三个目录，有了这几个自动生成的客户端相关操作包，我们就可以去访问 CRD 资源了，可以和使用内置的资源对象一样去对 CronTab 进行 List 和 Watch 操作了。
编写控制器
可以参考前面编写控制器的方式，首先要先获取访问资源对象的 ClientSet，在项目根目录下面新建 main.go 文件
package main
import (
"flag"
"os"
"os/signal"
"path/filepath"
"syscall"
"time"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/client-go/util/homedir"
"k8s.io/klog"
clientset "github.com/guilinonline/controller-demo/pkg/client/clientset/versioned"
informers "github.com/guilinonline/controller-demo/pkg/client/informers/externalversions"
)
var (
onlyOneSignalHandler = make(chan struct{})
shutdownSignals = []os.Signal{os.Interrupt, syscall.SIGTERM}
)
// SetupSignalHandler 注册 SIGTERM 和 SIGINT 信号
// 返回一个 stop channel，该通道在捕获到第一个信号时被关闭
// 如果捕捉到第二个信号，程序将直接退出
func setupSignalHandler() (stopCh <-chan struct{}) {
// 当调用两次的时候 panics
close(onlyOneSignalHandler)
stop := make(chan struct{})
c := make(chan os.Signal, 2)
// Notify 函数让 signal 包将输入信号转发到 c
// 如果没有列出要传递的信号，会将所有输入信号传递到 c；否则只传递列出的输入信号
// 参考文档：https://cloud.tencent.com/developer/article/1645996
signal.Notify(c, shutdownSignals...)
go func() {
<-c
close(stop)
<-c
os.Exit(1) // 第二个信号，直接退出
}()
return stop
}
func initClient() (*kubernetes.Clientset, *rest.Config, error) {
var err error
var config *rest.Config
// inCluster（Pod）、KubeConfig（kubectl）
var kubeconfig *string
if home := homedir.HomeDir(); home != "" {
kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(可选) kubeconfig 文件的绝对路径")
} else {
kubeconfig = flag.String("kubeconfig", "", "kubeconfig 文件的绝对路径")
}
flag.Parse()
// 首先使用 inCluster 模式(需要去配置对应的 RBAC 权限，默认的sa是default->是没有获取deployments的List权限)
if config, err = rest.InClusterConfig(); err != nil {
// 使用 KubeConfig 文件创建集群配置 Config 对象
if config, err = clientcmd.BuildConfigFromFlags("", *kubeconfig); err != nil {
panic(err.Error())
}
}
// 已经获得了 rest.Config 对象
// 创建 Clientset 对象
kubeclient, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, config, err
}
return kubeclient, config, nil
}
func main() {
flag.Parse()
//设置一个信号处理，应用于优雅关闭
stopCh := setupSignalHandler()
_, cfg, err := initClient()
if err != nil {
klog.Fatalf("Error building kubernetes clientset: %s", err.Error())
}
// 实例化一个 CronTab 的 ClientSet
crontabClient, err := clientset.NewForConfig(cfg)
if err != nil {
klog.Fatalf("Error building crontab clientset: %s", err.Error())
}
// informerFactory 工厂类， 这里注入我们通过代码生成的 client
// clent 主要用于和 API Server 进行通信，实现 ListAndWatch
crontabInformerFactory := informers.NewSharedInformerFactory(crontabClient, time.Second*30)
// 实例化自定义控制器
controller := NewController(crontabInformerFactory.Stable().V1beta1().CronTabs())
// 启动 informer，开始List & Watch
go crontabInformerFactory.Start(stopCh)
if err = controller.Run(2, stopCh); err != nil {
klog.Fatalf("Error running controller: %s", err.Error())
}
}首先初始化一个用于访问 CronTab 资源的 ClientSet 对象，然后同样新建一个 CronTab 的 InformerFactory 实例，通过这个工厂实例可以去启动 Informer 开始对 CronTab 的 List 和 Watch 操作，然后同样我们要自己去封装一个自定义的控制器，在这个控制器里面去实现一个控制循环，不断对 CronTab 的状态进行调谐。
在项目根目录下新建 controller.go 文件，内容如下所示：
package main
import (
"fmt"
"time"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/util/runtime"
"k8s.io/apimachinery/pkg/util/wait"
"k8s.io/client-go/tools/cache"
"k8s.io/client-go/util/workqueue"
"k8s.io/klog"
crdv1beta1 "github.com/guilinonline/controller-demo/pkg/apis/stable/v1beta1"
informers "github.com/guilinonline/controller-demo/pkg/client/informers/externalversions/stable/v1beta1"
)
type Controller struct {
informer informers.CronTabInformer
workqueue workqueue.RateLimitingInterface
}
func NewController(informer informers.CronTabInformer) *Controller {
//使用client 和前面创建的 Informer，初始化了自定义控制器
controller := &Controller{
informer: informer,
// WorkQueue 的实现，负责同步 Informer 和控制循环之间的数据
workqueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "CronTab"),
}
klog.Info("Setting up crontab event handlers")
// informer 注册了三个 Handler（AddFunc、UpdateFunc 和 DeleteFunc）
// 分别对应 API 对象的“添加”“更新”和“删除”事件。
// 而具体的处理操作，都是将该事件对应的 API 对象加入到工作队列中
informer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: controller.enqueueCronTab,
UpdateFunc: func(old, new interface{}) {
oldObj := old.(*crdv1beta1.CronTab)
newObj := new.(*crdv1beta1.CronTab)
// 如果资源版本相同则不处理
if oldObj.ResourceVersion == newObj.ResourceVersion {
return
}
controller.enqueueCronTab(new)
},
DeleteFunc: controller.enqueueCronTabForDelete,
})
return controller
}
func (c *Controller) Run(threadiness int, stopCh <-chan struct{}) error {
defer runtime.HandleCrash()
defer c.workqueue.ShutDown()
// 记录开始日志
klog.Info("Starting CronTab control loop")
klog.Info("Waiting for informer caches to sync")
if ok := cache.WaitForCacheSync(stopCh, c.informer.Informer().HasSynced); !ok {
return fmt.Errorf("failed to wait for caches to sync")
}
klog.Info("Starting workers")
for i := 0; i < threadiness; i++ {
go wait.Until(c.runWorker, time.Second, stopCh)
}
klog.Info("Started workers")
<-stopCh
klog.Info("Shutting down workers")
return nil
}
// runWorker 是一个死循环，一直会调用 c.processNextWorkItem 从workqueue读取元素
func (c *Controller) runWorker() {
for c.processNextWorkItem() {
}
}
// 从workqueue消费元素
func (c *Controller) processNextWorkItem() bool {
obj, shutdown := c.workqueue.Get()
if shutdown {
return false
}
err := func(obj interface{}) error {
defer c.workqueue.Done(obj)
var key string
var ok bool
if key, ok = obj.(string); !ok {
c.workqueue.Forget(obj)
runtime.HandleError(fmt.Errorf("expected string in workqueue but got %#v", obj))
return nil
}
if err := c.syncHandler(key); err != nil {
return fmt.Errorf("error syncing '%s': %s", key, err.Error())
}
c.workqueue.Forget(obj)
klog.Infof("Successfully synced '%s'", key)
return nil
}(obj)
if err != nil {
runtime.HandleError(err)
return true
}
return true
}
// 从 Informer 维护的缓存中拿到了它所对应的 CronTab 对象
func (c *Controller) syncHandler(key string) error {
namespace, name, err := cache.SplitMetaNamespaceKey(key)
if err != nil {
runtime.HandleError(fmt.Errorf("invalid resource key: %s", key))
return nil
}
crontab, err := c.informer.Lister().CronTabs(namespace).Get(name)
//从缓存中拿不到这个对象,那就意味着这个 CronTab 对象的 Key 是通过前面的“删除”事件添加进工作队列的。
if err != nil {
if errors.IsNotFound(err) {
// 对应的 crontab 对象已经被删除了
klog.Warningf("[CronTabCRD] %s/%s does not exist in local cache, will delete it from CronTab ...",
namespace, name)
klog.Infof("[CronTabCRD] deleting crontab: %s/%s ...", namespace, name)
return nil
}
runtime.HandleError(fmt.Errorf("failed to get crontab by: %s/%s", namespace, name))
return err
}
klog.Infof("[CronTabCRD] try to process crontab: %#v ...", crontab)
return nil
}
func (c *Controller) enqueueCronTab(obj interface{}) {
var key string
var err error
if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {
runtime.HandleError(err)
return
}
c.workqueue.AddRateLimited(key)
}
func (c *Controller) enqueueCronTabForDelete(obj interface{}) {
var key string
var err error
key, err = cache.DeletionHandlingMetaNamespaceKeyFunc(obj)
if err != nil {
runtime.HandleError(err)
return
}
c.workqueue.AddRateLimited(key)
}我们这里自定义的控制器只封装了一个 Informer 和一个限速队列，我们当然也可以在里面添加一个用于访问本地缓存的 Indexer，但实际上 Informer 中已经包含了 Lister，对于 List 和 Get 操作都会去通过 Indexer 从本地缓存中获取数据，所以只用一个 Informer 也是完全可行的。
同样在 Informer 中注册了3个事件处理器，将监听的事件获取到后送入 workqueue 队列，然后通过控制器的控制循环不断从队列中消费数据，根据获取的 key 来获取数据判断对象是需要删除还是需要进行其他业务处理，这里我们同样也只是打印出了对应的操作日志，对于实际的项目则进行相应的业务逻辑处理即可。
到这里一个完整的自定义 API 对象和它所对应的自定义控制器就编写完毕了。
测试
接下来我们可以直接编译代码：
$ go build -ldflags "-s -w" -v -o crontab-controller .编译完成后，会生成 crontab-controller 的二进制文件，由于我们代码中支持 inCluster 和 kubeconfig 两种模式，所以我们可以在 Kubernetes 集群中或者在本地（前提是可以访问 Kubernetes 集群）都可以运行该控制器。
比如我们在本地运行，由于 ~/.kube/config 配置了访问 Kubernetes 集群的文件，所以我们直接运行该控制器即可：
$ ./crontab-controller
I1010 15:18:06.402954 82070 controller.go:31] Setting up crontab event handlers
I1010 15:18:06.403365 82070 controller.go:57] Starting CronTab control loop
I1010 15:18:06.403377 82070 controller.go:58] Waiting for informer caches to sync
I1010 15:18:06.605476 82070 controller.go:63] Starting workers
I1010 15:18:06.605582 82070 controller.go:68] Started workers现在我们来创建一个 CronTab 资源对象：
# crontab-demo.yaml
apiVersion: stable.example.com/v1beta1
kind: CronTab
metadata:
name: crontab-demo
namespace: default
spec:
image: "nginx:1.7.9"
cronSpec: "* * * * */5"
replicas: 2直接创建上面的对象，注意观察控制器的日志：
$ kubectl apply -f crontab-demo.yaml
crontab.stable.example.com/crontab-demo created
$ kubectl get crontab
NAME AGE
crontab-demo 70s在上面的资源对象创建成功后在控制器的日志中则会出现如下所示的信息：
......
I1010 15:18:06.605476 82070 controller.go:63] Starting workers
I1010 15:18:06.605582 82070 controller.go:68] Started workers
I1010 15:19:55.115241 82070 controller.go:132] [CronTabCRD] try to process crontab: &v1beta1.CronTab{TypeMeta:v1.TypeMeta{Kind:"", APIVersion:""}, ObjectMeta:v1.ObjectMeta{Name:"crontab-demo", GenerateName:"", Namespace:"default", SelfLink:"/apis/stable.example.com/v1beta1/namespaces/default/crontabs/crontab-demo", UID:"1368bca5-4189-4f1a-9e8c-1d216ff67c24", ResourceVersion:"134155788", Generation:1, CreationTimestamp:v1.Time{Time:time.Time{wall:0x0, ext:63737911195, loc:(*time.Location)(0x29d5a20)}}, DeletionTimestamp:(*v1.Time)(nil), DeletionGracePeriodSeconds:(*int64)(nil), Labels:map[string]string(nil), Annotations:map[string]string{"kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"stable.example.com/v1beta1\",\"kind\":\"CronTab\",\"metadata\":{\"annotations\":{},\"name\":\"crontab-demo\",\"namespace\":\"default\"},\"spec\":{\"cronSpec\":\"* * * * */5\",\"image\":\"nginx:1.7.9\",\"replicas\":2}}\n"}, OwnerReferences:[]v1.OwnerReference(nil), Finalizers:[]string(nil), ClusterName:"", ManagedFields:[]v1.ManagedFieldsEntry(nil)}, Spec:v1beta1.CronTabSpec{CronSpec:"* * * * */5", Image:"nginx:1.7.9", Replicas:2}} ...
I1010 15:19:55.116099 82070 controller.go:99] Successfully synced 'default/crontab-demo'可以看到，我们上面创建 crontab-demo.yaml 的操作，触发了 EventHandler 的添加事件，从而被放进了工作队列。然后控制器的控制循环从队列里拿到这个对象，并且打印出了正在处理这个 CronTab 对象的日志信息。
同样我们删除这个资源的时候，也会有对应的提示：
$ kubectl delete crontab crontab-demo
crontab.stable.example.com "crontab-demo" deleted当删除成功后对应的控制器出现了如下所示的日志信息：
W1010 15:23:11.738930 82070 controller.go:124] [CronTabCRD] default/crontab-demo does not exist in local cache, will delete it from CronTab ...
I1010 15:23:11.738952 82070 controller.go:126] [CronTabCRD] deleting crontab: default/crontab-demo ...
I1010 15:23:11.738961 82070 controller.go:99] Successfully synced 'default/crontab-demo'这就是开发自定义 CRD 控制器的基本流程，当然我们还可以在事件处理的业务逻辑中去记录一些 Events 信息，这样我们就可以通过 Event 去了解我们资源的状态了。
WEB架构
安全监控体系
集群架构
