Mencipta pengawal kubernetes tersuai dalam Go

Sebelum Melaksanakan pengawal tersuai dalam Go mari kita fahami dahulu apa itu Pengawal Kubernetes dan Definisi Sumber Pelanggan (CRD)

Pengawal Kubernetes

Pengawal Kubernetes ialah komponen satah kawalan yang memantau keadaan gugusan kubernetes secara berterusan dan mengambil tindakan untuk memastikan keadaan gugusan sebenar sepadan dengan keadaan yang diingini. Ia membuat perubahan yang cuba mengalihkan keadaan semasa lebih dekat kepada keadaan yang dikehendaki.

Definisi Sumber Pelanggan (CRD)

Definisi Sumber Tersuai (CRD) ialah satu cara untuk melanjutkan API Kubernetes untuk mencipta sumber tersuai kami sendiri. Sumber tersuai ini boleh mewakili sebarang jenis objek yang ingin kami uruskan dalam kelompok Kubernetes kami.

Mencipta Definisi Sumber Tersuai (CRD) sendiri

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

Gunakan fail ini menggunakan arahan kubectl dan apabila kami melihat crd yang tersedia dalam kluster kami, kami dapat melihat crd yang kami buat-

Mencipta Sumber Tersuai (CR)

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

Gunakan fail ini menggunakan arahan kubectl

Sekarang mari kita teruskan untuk mencipta pengawal tersuai sendiri

Mencipta pengawal kubernetes tersuai

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
}

Sekarang apabila kita membina Program Go ini dan menjalankannya-
pergi bina -o k8s-controller .
./k8s-controller

Kini apabila kami menambah, mengemas kini atau memadamkan sumber tersuai yang dibuat di atas, kami mendapat log aktifnya dalam terminal kami. jadi ini bermakna pengawal kami sedang memantau CRD kami.

Atas ialah kandungan terperinci Mencipta pengawal kubernetes tersuai dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!