Erstellen eines benutzerdefinierten Kubernetes-Controllers in Go

Bevor wir einen benutzerdefinierten Controller in Go implementieren, wollen wir zunächst verstehen, was Kubernetes Controller und Customer Resource Definition (CRD) ist

Kubernetes-Controller

Ein Kubernetes-Controller ist eine Komponente der Steuerungsebene, die den Zustand des Kubernetes-Clusters kontinuierlich überwacht und Maßnahmen ergreift, um sicherzustellen, dass der tatsächliche Zustand des Clusters dem gewünschten Zustand entspricht. Er nimmt Änderungen vor und versucht, den aktuellen Zustand näher an den gewünschten Zustand zu bringen.

Kundenressourcendefinition (CRD)

Custom Resource Definition (CRD) ist eine Möglichkeit, die Kubernetes-API zu erweitern, um unsere eigenen benutzerdefinierten Ressourcen zu erstellen. Diese benutzerdefinierten Ressourcen können jede Art von Objekt darstellen, die wir in unserem Kubernetes-Cluster verwalten möchten.

Erstellen einer eigenen benutzerdefinierten Ressourcendefinition (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

Wenden Sie diese Datei mit dem Befehl kubectl an und wenn wir die verfügbaren CRDs in unserem Cluster sehen, können wir den CRD sehen, den wir erstellt haben-

Erstellen einer benutzerdefinierten Ressource (CR)

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

Wenden Sie diese Datei mit dem Befehl kubectl an

Lassen Sie uns nun mit der Erstellung eines eigenen benutzerdefinierten Controllers fortfahren

Erstellen eines benutzerdefinierten Kubernetes-Controllers

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
}

Wenn wir jetzt dieses Go-Programm erstellen und ausführen-
go build -o k8s-controller .
./k8s-controller

Jetzt erhalten wir jedes Mal, wenn wir die oben erstellte benutzerdefinierte Ressource hinzufügen, aktualisieren oder löschen, aktive Protokolle davon in unserem Terminal. Das bedeutet also, dass unser Controller unser CRD überwacht.

Das obige ist der detaillierte Inhalt vonErstellen eines benutzerdefinierten Kubernetes-Controllers in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!