Cara yang paling berkesan untuk menulis operator Kubernet adalah untuk menggunakan Go untuk menggabungkan Kubebuilder dan pengawal-runtime. 1. Memahami corak pengendali: Tentukan sumber tersuai melalui CRD, tulis pengawal untuk mendengar perubahan sumber dan lakukan gelung perdamaian untuk mengekalkan keadaan yang diharapkan. 2. Inisialisasi projek dengan Kubebuilder dan buat API untuk menghasilkan CRD, pengawal, dan fail konfigurasi secara automatik. 3. Tentukan spec dan struktur status CRD dalam API/V1/MYAPP_TYPES.GO, dan RUN membuat nyata untuk menghasilkan CRD YAML. 4. Melaksanakan logik perniagaan dalam kaedah penyelarasan pengawal, dan gunakan R.Create, R.Update dan kaedah lain untuk menguruskan sumber Kubernet. 5. Tentukan keizinan RBAC melalui anotasi GO, membina imej menggunakan membuat manifes dan membuat pembina docker, dan menggunakannya melalui Kubectl atau membuat penggunaan. 6. Ikuti Amalan Terbaik: Pastikan perdamaian idempotence logik, mengendalikan kesilapan yang munasabah dan gunakan requeueafter untuk mengawal semula, menambah log dan peristiwa, dan gunakan finalis dan webhooks jika perlu. 7. Gunakan Envtest untuk ujian integrasi dan fakeclient untuk ujian unit. Akhirnya, teras pembangunan pengendali adalah untuk menentukan CRD, menulis logik harmonik, menggunakan pengawal-runtime untuk memudahkan interaksi K8S, dan ujian dan penggunaan lengkap melalui alat toolchains yang matang.

Menulis pengendali Kubernet di GO adalah salah satu cara yang paling berkesan untuk memperluaskan pesawat kawalan Kubernet untuk menguruskan aplikasi yang kompleks dan berkesudahan. Pengendali menggunakan sumber tersuai (CRS) dan pengawal untuk mengautomasikan tugas -tugas yang pengendali manusia sebaliknya akan melakukan sandaran, skala, peningkatan, dan failover. Pergi adalah pilihan semulajadi kerana Kubernetes sendiri ditulis dalam GO, dan ekosistem (seperti klien-pergi dan pengawal-runtime) adalah matang dan didokumentasikan dengan baik.

Berikut adalah panduan praktikal untuk membantu anda memulakan dan memahami komponen utama.

1. Memahami corak pengendali

Pengendali menggabungkan definisi sumber tersuai (CRD) dengan pengawal yang mengawasi perubahan kepada sumber itu dan mengambil tindakan untuk mendamaikan keadaan yang dikehendaki dengan keadaan sebenar kluster.

• Sumber Custom (CR) : A YAML Manifes Menentukan keadaan yang dikehendaki aplikasi anda (misalnya, MyAppDatabase ).
• Pengawal : Program GO yang menonton objek MyAppDatabase dan menguruskan sumber Kubernet (contohnya, statefulsets, perkhidmatan) untuk memadankan spec.

Ini berdasarkan corak informer dan gelung perdamaian .

2. Gunakan Kubebuilder dan Pengawal-Runtime

Cara paling mudah untuk membina pengendali di Go adalah menggunakan Kubebuilder , sebahagian daripada Kubernetes SIGS, yang projek perancah menggunakan pengawal-runtime -perpustakaan yang mengendalikan butiran peringkat rendah seperti persediaan pelanggan, pengendalian acara, dan perdamaian.

Pasang alat:

 # Pasang Kubebuilder
curl -l -o https://go.kubebuilder.io/dl/latest/$(go env goos)/$ (go env goarch)
tar -xzf kubebuilder _*_ $ (go env goos) _ $ (go env goarch) .tar.gz
sudo mv kubebuilder _*_ $ (go env goos) _ $ (go env goarch)/usr/local/kubebuilder
Laluan Eksport = $ Path:/usr/Local/Kubebuilder/Bin

Buat projek baru:

 Mkdir MyApp-Operator
CD MyApp-Operator
KUBEBUILDER INIT --Domain Example.com-Repo Example.com/myApp-Operator
Kubebuilder Create API -Apps Group --version v1 --Kind MyApp

Ini menjana:

• api/v1/myapp_types.go - Tentukan skema CRD anda.
• controllers/myapp_controller.go - di mana anda menulis logik perdamaian.
• config/ - Kustomize manifests untuk menggunakan CRD dan RBAC.

3. Tentukan sumber tersuai anda

Edit api/v1/myapp_types.go :

 Taipkan myAppspec struct {
    Replika int32 `json:" replika "`
    String imej `json:" imej "`
    Pelabuhan int32 `json:" port "`
}

Taipkan myAppStatus struct {
    ReadyReplicas Int32 `json:" ReadyReplicas "`
    Syarat [] metav1.condition `json:" syarat, omitempty "`
}

Jalankan make manifests untuk menjana crd yaml dari anotasi Go.

4. Melaksanakan logik perdamaian

Dalam controllers/myapp_controller.go , kaedah Reconcile dipanggil apabila sumber myApp berubah.

 Func (R *myAppReconciler) Rekoncile (CTX Context.Context, Req Ctrl.Request) (Ctrl.Result, error) {
    log: = r.log.withValues ("myApp", req.namespacedName)

    var myapp myapp
    jika err: = r.get (ctx, req.namespacedName, & myApp); err! = nil {
        kembali ctrl.result {}, client.ignorenotFound (err)
    }

    // pastikan penyebaran wujud
    DesiredDep: = & appsv1.deployment {
        ObjectMeta: Metav1.ObjectMeta {
            Nama: MyApp.Name,
            Ruang nama: myapp.namespace,
        },
        Spec: appsv1.deploymentspec {
            Replika: & myapp.spec.replicas,
            Pemilih: & metav1.labelselector {
                MatchLabels: Map [String] String {"App": myapp.name},
            },
            Templat: coreev1.podtemplatespec {
                ObjectMeta: Metav1.ObjectMeta {
                    Label: peta [string] string {"app": myapp.name},
                },
                Spec: coreev1.podspec {
                    Bekas: [] coreev1.container {
                        {
                            Nama: "App",
                            Imej: myapp.spec.image,
                            Port: [] coreev1.containerport {{containerport: myapp.spec.port}},
                        },
                    },
                },
            },
        },
    }

    // Gunakan pelanggan pengawal-runtime untuk membuat atau mengemas kini
    jika err: = r.create (ctx, dikehendaki); err! = nil {
        jika! errors.isalreadyexists (err) {
            kembali ctrl.result {}, err
        }
    }

    // status kemas kini
    myapp.status.readyReplicas = 0 // kemas kini dari penggunaan sebenar
    jika err: = r.status (). UPDATE (CTX, & myApp); err! = nil {
        kembali ctrl.result {}, err
    }

    kembali ctrl.result {}, nil
}

Gunakan r.Create , r.Update , r.Patch , atau r.Delete untuk menguruskan objek.

5. Tambah RBAC dan gunakan

Kubebuilder Menggunakan GO Anotations untuk Menjana Peraturan RBAC:

 "
"
// KUBEBUILDER: RBAC: Kumpulan = Core, Resources = Pods, Verbs = List

Jalankan:

 Membuat manifes
Buat Docker-Build IMG = MyApp-Operator: v0.0.1
Kubectl Apply -F Config/Crd/Bases/Apps.example.com_myapps.yaml
KUBECTL Buat Pengendalian MyApp-Operator --Image = MyApp-Operator: v0.0.1

Atau gunakan make deploy IMG=myapp-operator:v0.0.1 Jika menggunakan persediaan kustomize lalai.

6. Amalan Terbaik

• Idempotency : Gelung mendamaikan boleh dijalankan beberapa kali -Mempertahankan operasi adalah selamat untuk diulangi.
• Pengendalian ralat : kesilapan pulangan ke permintaan; Gunakan ctrl.Result{RequeueAfter: time.Second} untuk cek berkala.
• Pembalakan & Acara : Gunakan r.Log dan r.Recorder.Event() untuk memancarkan peristiwa Kubernet.
• Finalis : Gunakannya apabila anda perlu melakukan pembersihan sebelum CR dipadamkan.
• WebHooks : Tambah Pengesahan (ValidateArmissionWebHook) atau lalai (MutatingAdmissionWebHook) melalui kubebuilder create webhook .

7. Ujian

• Gunakan envtest untuk ujian integrasi yang bermula ETCD dan Kube-Apiserver secara tempatan.
• Tulis ujian unit untuk logik perdamaian anda menggunakan fakeclient .

Persediaan Ujian Contoh:

 import (
    "sigs.k8s.io/controller-runtime/pkg/envtest"
)

var testenv *envtest.environment

Pada asasnya, membina pengendali Kubernet di GO beralih ke:

• Menentukan CRD dengan kubebuilder
• Menulis pengawal yang mendamaikan yang dikehendaki berbanding keadaan sebenar
• Menggunakan controller-runtime untuk mengendalikan interaksi kubernet
• Ujian dengan envtest dan menggunakan dengan manifes standard

Ia tidak sepele, tetapi perkakas telah matang banyak-Kubebuilder dan pengawal-runtime melakukan kebanyakan mengangkat berat. Mulakan kecil, mengautomasikan satu perkara dengan baik, dan berkembang dari sana.

Atas ialah kandungan terperinci Membangunkan pengendali Kubernet di mana sahaja. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!