$ mkdir operator-crd && cd operator-crd
$ go mod init operator-crd
$ mkdir -p pkg/apis/example.com/v1

// +k8s:deepcopy-gen=package
// +groupName=example.com
package v1

package v1
import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
// BarSpec defines the desired state of Bar
type BarSpec struct {
    // INSERT ADDITIONAL SPEC FIELDS -- desired state of cluster
    DeploymentName string `json:"deploymentName"`
    Image          string `json:"image"`
    Replicas       *int32 `json:"replicas"`
}
// BarStatus defines the observed state of Bar.
// It should always be reconstructable from the state of the cluster and/or outside world.
type BarStatus struct {
    // INSERT ADDITIONAL STATUS FIELDS -- observed state of cluster
}
// 下面這個(gè)一定不能少，少了的話不能生成 lister 和 informer
// +genclient  
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// Bar is the Schema for the bars API
// +k8s:openapi-gen=true
type Bar struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`
    Spec   BarSpec   `json:"spec,omitempty"`
    Status BarStatus `json:"status,omitempty"`
}
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// BarList contains a list of Bar
type BarList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata,omitempty"`
    Items           []Bar `json:"items"`
}

package v1
import (
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
)
// SchemeGroupVersion 注冊自己的自定義資源
var SchemeGroupVersion = schema.GroupVersion{Group: "example.com", Version: "v1"}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
    return SchemeGroupVersion.WithKind(kind).GroupKind()
}
// 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 {
    // 添加 Bar 與 BarList這兩個(gè)資源到 scheme
    scheme.AddKnownTypes(SchemeGroupVersion,
        &Bar{},
        &BarList{},
    )
    metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
    return nil
}

$ controller-gen crd paths=./... output:crd:dir=crd

---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: (devel)
  creationTimestamp: null
  name: bars.example.com
spec:
  group: example.com
  names:
    kind: Bar
    listKind: BarList
    plural: bars
    singular: bar
  scope: Namespaced
  versions:
  - name: v1
    schema:
      openAPIV3Schema:
        description: Bar is the Schema for the bars API
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
              of an object. Servers should convert recognized schemas to the latest
              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
              object represents. Servers may infer this from the endpoint the client
              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: BarSpec defines the desired state of Bar
            properties:
              deploymentName:
                description: INSERT ADDITIONAL SPEC FIELDS -- desired state of cluster
                type: string
              image:
                type: string
              replicas:
                format: int32
                type: integer
            required:
            - deploymentName
            - image
            - replicas
            type: object
          status:
            description: BarStatus defines the observed state of Bar. It should always
              be reconstructable from the state of the cluster and/or outside world.
            type: object
        type: object
    served: true
    storage: true

$ tree
.
├── crd
│?? └── example.com_bars.yaml
├── go.mod
├── go.sum
└── pkg
    └── apis
        └── example.com
            └── v1
                ├── doc.go
                ├── register.go
                └── types.go
5 directories, 6 files

$ mkdir hack && cd hack

// +build tools
// 建立 tools.go 來依賴 code-generator
// 因?yàn)樵跊]有代碼使用 code-generator 時(shí)，go module 默認(rèn)不會(huì)為我們依賴此包.
package tools
import _ "k8s.io/code-generator"

#!/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" \
  operator-crd/pkg/client operator-crd/pkg/apis example.com:v1 \
  --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

#!/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

/*
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.
*/

$ go mod vendor

$ chmod +x ./hack/update-codegen.sh
$./hack/update-codegen.sh 
Generating deepcopy funcs
Generating clientset for example.com:v1 at operator-crd/pkg/client/clientset
Generating listers for example.com:v1 at operator-crd/pkg/client/listers
Generating informers for example.com:v1 at operator-crd/pkg/client/informers

$  tree pkg                
pkg
├── apis
│?? └── example.com
│??     └── v1
│??         ├── 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
    │??         └── example.com
    │??             └── v1
    │??                 ├── bar.go
    │??                 ├── doc.go
    │??                 ├── example.com_client.go
    │??                 ├── fake
    │??                 │?? ├── doc.go
    │??                 │?? ├── fake_bar.go
    │??                 │?? └── fake_example.com_client.go
    │??                 └── generated_expansion.go
    ├── informers
    │?? └── externalversions
    │??     ├── example.com
    │??     │?? ├── interface.go
    │??     │?? └── v1
    │??     │??     ├── bar.go
    │??     │??     └── interface.go
    │??     ├── factory.go
    │??     ├── generic.go
    │??     └── internalinterfaces
    │??         └── factory_interfaces.go
    └── listers
        └── example.com
            └── v1
                ├── bar.go
                └── expansion_generated.go
20 directories, 26 files

package main
import (
    "k8s.io/client-go/tools/clientcmd"
   	"k8s.io/klog/v2"
    clientset "operator-crd/pkg/client/clientset/versioned"
    "operator-crd/pkg/client/informers/externalversions"
    "time"
    "os"
    "os/signal"
    "syscall"
)
var (
    onlyOneSignalHandler = make(chan struct{})
    shutdownSignals      = []os.Signal{os.Interrupt, syscall.SIGTERM}
)
// 注冊 SIGTERM 和 SIGINT 信號
// 返回一個(gè) stop channel， 該通道在捕獲到第一個(gè)信號時(shí)被關(guān)閉
// 如果捕獲到第二個(gè)信號，程序直接退出
func setupSignalHandler() (stopCh <-chan struct{}) {
    // 當(dāng)調(diào)用兩次的時(shí)候 panics
    close(onlyOneSignalHandler)
    stop := make(chan struct{})
    c := make(chan os.Signal, 2)
    // Notify 函數(shù)讓 signal 包將輸入信號轉(zhuǎn)發(fā)到c
    // 如果沒有列出要傳遞的信號，會(huì)將所有輸入信號傳遞到 c； 否則只會(huì)傳遞列出的輸入信號
    signal.Notify(c, shutdownSignals...)
    go func() {
        <-c
        close(stop)
        <-c
        os.Exit(1) // 第二個(gè)信號直接退出
    }()
    return stop
}
func main() {
    stopCh := setupSignalHandler()
    // 獲取config
    config, err := clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
    if err != nil {
        klog.Fatalln(err)
    }
    // 通過config構(gòu)建clientSet
    // 這里的clientSet 是 Bar 的
    clientSet, err := clientset.NewForConfig(config)
    if err != nil {
        klog.Fatalln(err)
    }
    // informerFactory 工廠類， 這里注入我們通過代碼生成的 client
    // client 主要用于和 API Server 進(jìn)行通信，實(shí)現(xiàn) ListAndWatch
    factory := externalversions.NewSharedInformerFactory(clientSet, time.Second*30)
    // 實(shí)例化自定義控制器
    controller := NewController(factory.Example().V1().Bars())
    // 啟動(dòng) informer，開始list 和 watch
    go factory.Start(stopCh)
    // 啟動(dòng)控制器
    if err = controller.Run(2, stopCh); err != nil {
        klog.Fatalf("Error running controller: %s", err.Error())
    }
}

package main
import (
    "fmt"
    "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/v2"
    v1 "operator-crd/pkg/apis/example.com/v1"
    "time"
    informers "operator-crd/pkg/client/informers/externalversions/example.com/v1"
)
type Controller struct {
    informer  informers.BarInformer
    workqueue workqueue.RateLimitingInterface
}
func NewController(informer informers.BarInformer) *Controller {
    controller := &Controller{
        informer: informer,
        // WorkQueue 的實(shí)現(xiàn)，負(fù)責(zé)同步 Informer 和控制循環(huán)之間的數(shù)據(jù)
        workqueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "bar"),
    }
    klog.Info("Setting up Bar event handlers")
    // informer 注冊了三個(gè) Handler（AddFunc、UpdateFunc 和 DeleteFunc）
    // 分別對應(yīng) API 對象的“添加”“更新”和“刪除”事件。
    // 而具體的處理操作，都是將該事件對應(yīng)的 API 對象加入到工作隊(duì)列中
    informer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc:    controller.addBar,
        UpdateFunc: controller.updateBar,
        DeleteFunc: controller.deleteBar,
    })
    return controller
}
func (c *Controller) Run(thread int, stopCh <-chan struct{}) error {
    defer runtime.HandleCrash()
    defer c.workqueue.ShuttingDown()
    // 記錄開始日志
    klog.Info("Starting Bar control loop")
    klog.Info("Waiting for informer caches to sync")
    // 等待緩存同步數(shù)據(jù)
    if ok := cache.WaitForCacheSync(stopCh, c.informer.Informer().HasSynced); !ok {
        return fmt.Errorf("failed to wati for caches to sync")
    }
    klog.Info("Starting workers")
    for i := 0; i < thread; i++ {
        go wait.Until(c.runWorker, time.Second, stopCh)
    }
    klog.Info("Started workers")
    <-stopCh
    klog.Info("Shutting down workers")
    return nil
}
// runWorker 是一個(gè)不斷運(yùn)行的方法，并且一直會(huì)調(diào)用 c.processNextWorkItem 從 workqueue讀取消息
func (c *Controller) runWorker() {
    for c.processNExtWorkItem() {
    }
}
// 從workqueue讀取和讀取消息
func (c *Controller) processNExtWorkItem() bool {
    // 獲取 item
    item, shutdown := c.workqueue.Get()
    if shutdown {
        return false
    }
    if err := func(item interface{}) error {
        // 標(biāo)記以及處理
        defer c.workqueue.Done(item)
        var key string
        var ok bool
        if key, ok = item.(string); !ok {
            // 判讀key的類型不是字符串，則直接丟棄
            c.workqueue.Forget(item)
            runtime.HandleError(fmt.Errorf("expected string in workqueue but got %#v", item))
            return nil
        }
        if err := c.syncHandler(key); err != nil {
            return fmt.Errorf("error syncing '%s':%s", item, err.Error())
        }
        c.workqueue.Forget(item)
        return nil
    }(item); err != nil {
        runtime.HandleError(err)
        return false
    }
    return true
}
// 嘗試從 Informer 維護(hù)的緩存中拿到了它所對應(yīng)的 Bar 對象
func (c *Controller) syncHandler(key string) error {
    namespace, name, err := cache.SplitMetaNamespaceKey(key)
    if err != nil {
        runtime.HandleError(fmt.Errorf("invalid respirce key:%s", key))
        return err
    }
    bar, err := c.informer.Lister().Bars(namespace).Get(name)
    if err != nil {
        if errors.IsNotFound(err) {
            // 說明是在刪除事件中添加進(jìn)來的
            return nil
        }
        runtime.HandleError(fmt.Errorf("failed to get bar by: %s/%s", namespace, name))
        return err
    }
    fmt.Printf("[BarCRD] try to process bar:%#v ...", bar)
    // 可以根據(jù)bar來做其他的事。
    // todo
    return nil
}
func (c *Controller) addBar(item interface{}) {
    var key string
    var err error
    if key, err = cache.MetaNamespaceKeyFunc(item); err != nil {
        runtime.HandleError(err)
        return
    }
    c.workqueue.AddRateLimited(key)
}
func (c *Controller) deleteBar(item interface{}) {
    var key string
    var err error
    if key, err = cache.DeletionHandlingMetaNamespaceKeyFunc(item); err != nil {
        runtime.HandleError(err)
        return
    }
    fmt.Println("delete crd")
    c.workqueue.AddRateLimited(key)
}
func (c *Controller) updateBar(old, new interface{}) {
    oldItem := old.(*v1.Bar)
    newItem := new.(*v1.Bar)
    // 比較兩個(gè)資源版本，如果相同，則不處理
    if oldItem.ResourceVersion == newItem.ResourceVersion {
        return
    }
    c.workqueue.AddRateLimited(new)
}

I0512 16:51:33.922138   39032 controller.go:29] Setting up Bar event handlers
I0512 16:51:33.922255   39032 controller.go:47] Starting Bar control loop
I0512 16:51:33.922258   39032 controller.go:48] Waiting for informer caches to sync
I0512 16:51:34.023108   39032 controller.go:55] Starting workers
I0512 16:51:34.023153   39032 controller.go:60] Started workers

# bar.yaml
apiVersion: example.com/v1
kind: Bar
metadata:
  name: bar-demo
  namespace: default
spec:
  image: "nginx:1.17.1"
  deploymentName: example-bar
  replicas: 2

I0512 16:51:33.922138   39032 controller.go:29] Setting up Bar event handlers
I0512 16:51:33.922255   39032 controller.go:47] Starting Bar control loop
I0512 16:51:33.922258   39032 controller.go:48] Waiting for informer caches to sync
I0512 16:51:34.023108   39032 controller.go:55] Starting workers
I0512 16:51:34.023153   39032 controller.go:60] Started workers
[BarCRD] try to process bar:"bar-demo" ...