Comment regarder les CustomResourceDefinitions (CRD) dans Kubernetes avec Client-go ?

Regarder CustomResourceDefinitions (CRD) avec client-go

CustomResourceDefinitions (CRD) permettent aux utilisateurs d'étendre Kubernetes avec leurs propres ressources API. La surveillance des modifications apportées à ces ressources est essentielle pour les contrôleurs et les applications. Cependant, la bibliothèque client-go standard ne reconnaît pas les CRD par défaut.

Génération de clients personnalisés

Pour surveiller les CRD avec client-go, générez des clients personnalisés qui reconnaissent votre CRD spécifique. Cela implique d'utiliser les outils de génération de code fournis par Kubernetes pour créer des structures et des clients pour l'API de votre CRD.

Utiliser kubebuilder

L'approche recommandée pour générer des configurations client et des contrôleurs consiste à utiliser kubebuilder. Cet outil automatise le processus de génération de code, simplifiant ainsi la création de clients personnalisés.

Exemple de contrôleur

Voici un extrait de code simplifié d'un exemple de contrôleur qui surveille les modifications apportées à un 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>

Dans cet exemple :

• La fonction watchCRD crée un ensemble de clients Kubernetes et l'informe des CRD.
• Elle ajoute des gestionnaires d'événements à l'informateur pour recevoir des ajouts, des mises à jour et supprime les événements pour les CRD.
• Le contrôleur surveille indéfiniment les modifications à l'aide d'un canal wait.NeverStop.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!