如何从零开始编写一个Kubernetes CRD

package main

import (
    apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
    apiextensionsclient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
    // 创建一个API扩展客户端
    clientset, err := apiextensionsclient.NewForConfig(config)
    if err != nil {
        panic(err.Error())
    }

    // 定义一个新的CRD对象
    crd := &apiextensionsv1beta1.CustomResourceDefinition{
        ObjectMeta: metav1.ObjectMeta{Name: "foos.samplecontroller.k8s.io"},
        Spec: apiextensionsv1beta1.CustomResourceDefinitionSpec{
            Group:   "samplecontroller.k8s.io",
            Version: "v1alpha1",
            Names: apiextensionsv1beta1.CustomResourceDefinitionNames{
                Plural:     "foos",
                Singular:   "foo",
                Kind:       "Foo",
                ShortNames: []string{"foo"},
            },
            Scope: apiextensionsv1beta1.NamespaceScoped,
        },
    }

    // 使用API扩展客户端创建CRD
    _, err = clientset.ApiextensionsV1beta1().CustomResourceDefinitions().Create(crd)
    if err != nil {
        panic(err.Error())
    }
}

package main

import (
    "fmt"
    "time"

    "k8s.io/apimachinery/pkg/fields"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/util/workqueue"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/api/core/v1"
)

type Controller struct {
    indexer  cache.Indexer
    queue    workqueue.RateLimitingInterface
    informer cache.Controller
}

func NewController(queue workqueue.RateLimitingInterface, indexer cache.Indexer, informer cache.Controller) *Controller {
    return &Controller{
        informer: informer,
        indexer:  indexer,
        queue:    queue,
    }
}

func (c *Controller) processNextItem() bool {
    // Wait until there is a new item in the working queue
    key, quit := c.queue.Get()
    if quit {
        return false
    }
    // Tell the queue that we are done with processing this key. This unblocks the key for other workers
    // This allows safe parallel processing because two CRDs with the same key are never processed in
    // parallel.
    defer c.queue.Done(key)

    // Invoke the method containing the business logic
    err := c.syncToStdout(key.(string))
    // Handle the error if something went wrong during the execution of the business logic
    c.handleErr(err, key)
    return true
}

func (c *Controller) syncToStdout(key string) error {
    obj, exists, err := c.indexer.GetByKey(key)
    if err != nil {
        fmt.Errorf("Fetching object with key %s from store failed with %v", key, err)
        return err
    }

    if !exists {
        // Below we will warm up our cache with a CronTab, so that we will see a delete for one CronTab
        fmt.Printf("CronTab %s does not exist anymore\n", key)
    } else {
        // Note that you also have to check the uid if you have a local controlled resource, which
        // is dependent on the actual instance, to detect that a CronTab was recreated with the same name
        fmt.Printf("Sync/Add/Update for CronTab %s\n", obj.(*v1.Pod).GetName())
    }
    return nil
}

func (c *Controller) handleErr(err error, key interface{}) {
    if err == nil {
        // Forget about the #AddRateLimited history of the key on every successful synchronization.
        // This ensures that future processing of updates for this key is not delayed because of
        // an outdated error history.
        c.queue.Forget(key)
        return
    }

    // This controller retries 5 times if something goes wrong. After that, it stops trying.
    if c.queue.NumRequeues(key) < 5 {
        fmt.Errorf("Error syncing CronTab %v: %v", key, err)

        // Re-enqueue the key rate limited. Based on the rate limiter在Kubernetes中，CRD（CustomResourceDefinition）本身只是一个数据模式，而CRD控制器负责实现所需的功能[[2](https://www.sobyte.net/post/2022-03/k8s-crd-controller/)]。控制器会监听CRD实例（以及关联的资源）的CRUD事件，然后执行相应的业务逻辑。