Création d'un contrôleur Kubernetes personnalisé dans Go

Avant d'implémenter un contrôleur personnalisé dans Go, comprenons d'abord ce qu'est le contrôleur Kubernetes et la définition des ressources client (CRD)

Contrôleur Kubernetes

Un contrôleur Kubernetes est un composant du plan de contrôle qui surveille en permanence l'état du cluster Kubernetes et prend des mesures pour garantir que l'état réel du cluster correspond à l'état souhaité. Il apporte des modifications en tentant de rapprocher l'état actuel de l'état souhaité.

Définition des ressources client (CRD)

La définition de ressources personnalisées (CRD) est un moyen d'étendre l'API Kubernetes pour créer nos propres ressources personnalisées. Ces ressources personnalisées peuvent représenter tout type d'objet que nous souhaitons gérer au sein de notre cluster Kubernetes.

Création de votre propre définition de ressource personnalisée (CRD)

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: my-crds.com.shivam.kumar
spec:
  group: com.shivam.kumar
  names:
    kind: my-crd
    plural: my-crds
  scope: Namespaced
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            apiVersion:
              type: string
            kind:
              type: string
            metadata:
              type: object
            spec:
              type: object
              properties:
                description:
                  type: string

Appliquez ce fichier à l'aide de la commande kubectl et lorsque nous voyons les crd disponibles dans notre cluster, nous pouvons voir le crd que nous avons créé-

Création d'une ressource personnalisée (CR)

apiVersion: com.shivam.kumar/v1
kind: my-crd
metadata:
  name: my-custom-resource
spec:
  description: "My CRD instance"

Appliquez ce fichier à l'aide de la commande kubectl

Passons maintenant à la création de notre propre contrôleur personnalisé

Création d'un contrôleur Kubernetes personnalisé

package main

import (
    "context"
    "fmt"
    "path/filepath"

    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
    "k8s.io/apimachinery/pkg/watch"
    "k8s.io/client-go/dynamic"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
)

func main() {
    var kubeconfig string
    if home := homedir.HomeDir(); home != "" {
        kubeconfig = filepath.Join(home, ".kube", "config")
    }

    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        fmt.Println("Falling back to in-cluster config")
        config, err = rest.InClusterConfig()
        if err != nil {
            panic(err.Error())
        }
    }

    dynClient, err := dynamic.NewForConfig(config)
    if err != nil {
        panic(err.Error())
    }

    thefoothebar := schema.GroupVersionResource{Group: "com.shivam.kumar", Version: "v1", Resource: "my-crds"}

    informer := cache.NewSharedIndexInformer(
        &cache.ListWatch{
            ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
                return dynClient.Resource(thefoothebar).Namespace("").List(context.TODO(), options)
            },
            WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
                return dynClient.Resource(thefoothebar).Namespace("").Watch(context.TODO(), options)
            },
        },
        &unstructured.Unstructured{},
        0,
        cache.Indexers{},
    )

    informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            fmt.Println("Add event detected:", obj)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            fmt.Println("Update event detected:", newObj)
        },
        DeleteFunc: func(obj interface{}) {
            fmt.Println("Delete event detected:", obj)
        },
    })

    stop := make(chan struct{})
    defer close(stop)

    go informer.Run(stop)

    if !cache.WaitForCacheSync(stop, informer.HasSynced) {
        panic("Timeout waiting for cache sync")
    }

    fmt.Println("Custom Resource Controller started successfully")
    <-stop
}

Maintenant, lorsque nous construisons ce programme Go et l'exécutons-
allez build -o k8s-controller .
./k8s-contrôleur

Désormais, chaque fois que nous ajoutons, mettons à jour ou supprimons une ressource personnalisée créée ci-dessus, nous obtenons des journaux actifs dans notre terminal. cela signifie donc que notre contrôleur surveille notre CRD.

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!