How to Watch CustomResourceDefinitions (CRDs) in Kubernetes with Client-go?

Watching CustomResourceDefinitions (CRD) with client-go

CustomResourceDefinitions (CRDs) allow users to extend Kubernetes with their own API resources. Watching for changes to these resources is essential for controllers and applications. However, the standard client-go library does not recognize CRDs by default.

Generating Custom Clients

To watch for CRDs with client-go, generate custom clients that recognize your specific CRD. This involves using code generation tools provided by Kubernetes to create structs and clients for your CRD's API.

Using kubebuilder

The recommended approach for generating client configs and controllers is to use kubebuilder. This tool automates the code generation process, simplifying the creation of custom clients.

Example Controller

Here is a simplified code snippet from a sample controller that watches for changes to a CRD:

<code class="go">import (
    "github.com/pkg/errors"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/labels"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
    "k8s.io/apimachinery/pkg/util/wait"
    "k8s.io/client-go/informers"
    "k8s.io/client-go/kubernetes"
    clientset "k8s.io/client-go/kubernetes/typed/core/v1"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/tools/remotecommand"
)

// watchCRD watches for new/changed CustomResourceDefinitions (CRDs).
func watchCRD() error {
    // Create a new Kubernetes clientset.
    clientset, err := kubernetes.NewForConfig(restConfig)
    if err != nil {
        return errors.WithStack(err)
    }

    // Create an informer for list of CRDs.
    sharedInformerFactory := informers.NewSharedInformerFactory(clientset, 0)
    crdInformer := sharedInformerFactory.ApiextensionsV1().CustomResourceDefinitions().Informer()

    // Initialize the informer and wait for it to sync with API server.
    stopCh := make(chan struct{})
    crdInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            crd := obj.(*apiextensionsv1.CustomResourceDefinition)
            // Handle newly added CRD.
            fmt.Println("New CRD added:", crd.Name)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            crd := newObj.(*apiextensionsv1.CustomResourceDefinition)
            // Handle updated CRD.
            fmt.Println("CRD updated:", crd.Name)
        },
        DeleteFunc: func(obj interface{}) {
            crd := obj.(*apiextensionsv1.CustomResourceDefinition)
            // Handle deleted CRD.
            fmt.Println("CRD deleted:", crd.Name)
        },
    })
    sharedInformerFactory.Start(stopCh)
    <-wait.NeverStop

    return nil
}</code>

In this example:

• The watchCRD function creates a Kubernetes clientset and informs it about CRDs.
• It adds event handlers to the informer to receive add, update, and delete events for CRDs.
• The controller watches indefinitely for changes using a wait.NeverStop channel.

The above is the detailed content of How to Watch CustomResourceDefinitions (CRDs) in Kubernetes with Client-go?. For more information, please follow other related articles on the PHP Chinese website!