Entwicklung von Kubernetes -Betreibern in Go

Der effizienteste Weg, um einen Kubernetes-Operator zu schreiben, besteht darin, GO zu verwenden, um Kubebuilder und Controller-Runtime zu kombinieren. 1. Verstehen Sie das Bedienermuster: Definieren Sie benutzerdefinierte Ressourcen über CRD, schreiben Sie einen Controller, um auf Ressourcenänderungen zu hören und Versöhnungsschleifen durchzuführen, um den erwarteten Zustand aufrechtzuerhalten. 2. Initialisieren Sie das Projekt mit Kubebuilder und erstellen Sie APIs, um automatisch CRDs, Controller und Konfigurationsdateien zu generieren. 3. Definieren Sie die Spezifikations- und Statusstrukturen von CRD in API/v1/myapp_types.go und rennen Sie Manifests, um CRD YAML zu generieren. 4. Implementieren Sie die Geschäftslogik in der Versöhnungsmethode des Controllers und verwenden Sie R.Create, R.Update und andere Methoden zur Verwaltung von Kubernetes -Ressourcen. 5. Definieren Sie die RBAC-Berechtigungen durch GO-Anmerkungen, erstellen Sie Bilder mithilfe von Manifests und machen Sie Docker-Build und stellen Sie sie über Kubectl ein oder machen Sie Bereitstellung. 6. Best Practices folgen: Stellen Sie die Abstimmung der logischen Idempotenz sicher, verarbeiten Sie Fehler angemessen und verwenden Sie Requeua, um Wiederholung zu steuern, Protokolle und Ereignisse hinzuzufügen und bei Bedarf Finalizer und Webhooks zu verwenden. 7. Verwenden Sie Envtest für Integrationstests und Fakeclient für Unit -Tests. Letztendlich besteht der Kern der Bedienerentwicklung darin, CRD zu definieren, harmonische Logik zu schreiben, die Controller-Runtime zu verwenden, um die K8s-Interaktion zu vereinfachen und Tests und Bereitstellungen durch reife Toolchains zu vervollständigen.

Das Schreiben von Kubernetes -Operatoren in Go ist eine der effektivsten Möglichkeiten, um die Kubernetes -Steuerebene für die Verwaltung komplexer, staatlicher Anwendungen zu erweitern. Ein Bediener verwendet benutzerdefinierte Ressourcen (CRS) und Controller, um Aufgaben zu automatisieren, die ein menschlicher Bediener sonst ausführen würde - wie Backups, Skalierung, Upgrades und Failover. Go ist die natürliche Wahl, da Kubernetes selbst in Go geschrieben ist und das Ökosystem (wie Client-Go und Controller-Runtime) reif und gut dokumentiert ist.

Hier ist ein praktischer Leitfaden, mit dem Sie anfangen und die Schlüsselkomponenten verstehen können.

1. Verstehen Sie das Operatormuster

Ein Operator kombiniert eine benutzerdefinierte Ressourcendefinition (CRD) mit einem Controller , der nach Änderungen dieser Ressource beobachtet und Maßnahmen ergriffen, um den gewünschten Zustand mit dem tatsächlichen Zustand des Clusters in Einklang zu bringen.

• Benutzerdefinierte Ressource (CR) : Ein YAML -Manifest, das den gewünschten Zustand Ihrer Anwendung definiert (z. B. MyAppDatabase ).
• Controller : Ein GO -Programm, mit MyAppDatabase -Objekte beobachtet und Kubernetes -Ressourcen (z. B. Statefuls Sets, Services) mit der Spezifikation übereinstimmt.

Dies basiert auf der Informanten-Muster- und Versöhnungsschleife .

2. Verwenden Sie Kubebuilder und Controller-Runtime

Der einfachste Weg, einen Betreiber in Go zu bauen, besteht darin, Kubebuilder , Teil der Kubernetes Sigs, zu verwenden, die Projekte mit der Verwendung von Controller-Runtime -Projekten-eine Bibliothek, die Details auf niedrigem Niveau wie Client-Setup, Ereignisbearbeitung und Versöhnung übernimmt.

Werkzeuge installieren:

 # Kubebuilder installieren
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
Exportpfad = $ path:/usr/local/kubebuilder/bin

Erstellen Sie ein neues Projekt:

 Mkdir MyApp-Operator
CD MyApp-Operator
Kubebuilder init ---domain example.com ---repo example.com/myapp-operator
Kubebuilder erstellen API -Gruppen -Apps --version v1 -Kind MyApp

Dies erzeugt:

• api/v1/myapp_types.go - Definieren Sie Ihr CRD -Schema.
• controllers/myapp_controller.go - wo Sie eine Versöhnungslogik schreiben.
• config/ - Kustomize Manifests für die Bereitstellung von CRD und RBAC.

3. Definieren Sie Ihre benutzerdefinierte Ressource

api/v1/myapp_types.go bearbeiten:

 Geben Sie MyAppspec struct {ein
    Replicas int32 `JSON:" Replicas "`
    Bildzeichenfolge `JSON:" Bild "`
    Port Int32 `JSON:" Port "`
}

Geben Sie MyAppstatus struct {ein {
    ReadyReplicas int32 `JSON:" ReadyReplicas "`
    Bedingungen [] metav1.Kondition `JSON:" Bedingungen, OmitEMpty "`
}

Run make manifests um CRD Yaml aus GO -Annotationen zu erzeugen.

4. Implementieren Sie die Versöhnungslogik

In controllers/myapp_controller.go wird die Reconcile aufgerufen, wenn sich eine MyApp -Ressource ändert.

 func (r *myAtreconciler) conc) (ctx context.context, req ctrl.request) (ctrl.result, error) {
    log: = r.log.withValues ("myapp", req.namespaceName)

    var myapp myapp
    wenn er err: = r.get (ctx, req.namespaceName, & myapp); err! = nil {
        return ctrl.result {}, client.ignorenotfound (err)
    }

    // Stellen Sie sicher, dass eine Bereitstellung vorliegt
    WANNEDDEP: = & appsv1.Deployment {
        Objektmeta: metav1.objectmeta {
            Name: myapp.name,
            Namespace: myapp.namespace,
        },
        Spec: Appsv1.DeploymentSpec {
            Repliken: & myapp.spec.replicas,
            Selector: & metav1.labelSelector {
                MatchLabels: Karte [String] String {"App": myapp.name},
            },
            Vorlage: corev1.podtemPlateSpec {
                Objektmeta: metav1.objectmeta {
                    Labels: Karte [String] String {"App": myapp.name},
                },
                Spec: corev1.podspec {
                    Container: [] corev1.container {
                        {
                            Name: "App",
                            Bild: myapp.spec.image,
                            Ports: [] corev1.containerport {{containerport: myapp.spec.port}},
                        },
                    },
                },
            },
        },
    }

    // Verwenden Sie den Client von Controller-Runtime, um zu erstellen oder zu aktualisieren
    wenn er err: = r.create (ctx, gewünschtdep); err! = nil {
        if! fehler.isalreadyexists (err) {
            return ctrl.result {}, err
        }
    }

    // Status aktualisieren
    MyApp.Status.Readyreplicas = 0 // Aktualisieren Sie aus der tatsächlichen Bereitstellung
    wenn er err: = r.Status (). Update (CTX, & myApp); err! = nil {
        return ctrl.result {}, err
    }

    return ctrl.result {}, nil
}

Verwenden Sie r.Create , r.Update , r.Patch oder r.Delete , um Objekte zu verwalten.

5. RBAC hinzufügen und bereitstellen

Kubebuilder verwendet GO -Anmerkungen, um RBAC -Regeln zu generieren:

 // Kubebuilder: RBAC: Gruppen = Apps.Example.com, Ressourcen = MyApps, Verbs = Get; Liste; Watch; creating; Update; Patch; Patch; löschen
// KUBEBUILD: RBAC: Gruppen = Apps, Ressourcen = Bereitstellungen, Verben = Get; List; Watch; creating; Update; Patch; löschen
// Kubebuilder: RBAC: Gruppen = Core, Ressourcen = Pods, Verben = Liste

Laufen:

 Manifests machen
Machen Sie Docker-Build IMG = MyApp-Operator: v0.0.1
kubectl anwenden -f -config/crd/bases/Apps.example.com_myapps.yaml
kubectl erstellen BereitstellungsmyApp-Operator-IMage = MyApp-Operator: v0.0.1

Oder verwenden Sie make deploy IMG=myapp-operator:v0.0.1 wenn das Standard-Kustomize-Setup verwendet wird.

6. Best Practices

• Idempotenz : Stimmen Loops können mehrmals ausgeführt werden - die Operationen können sicher wiederholt werden.
• Fehlerbehandlung : Rückgabefehler zur Anfrage zurück; Verwenden Sie ctrl.Result{RequeueAfter: time.Second} für periodische Überprüfungen.
• Protokollierung & Ereignisse : Verwenden Sie r.Log und r.Recorder.Event() um Kubernetes -Ereignisse zu emittieren.
• Finalizers : Verwenden Sie sie, wenn Sie die Reinigung durchführen müssen, bevor ein CR gelöscht wird.
• Webhooks : Fügen Sie die Validierung (ValidatingAdmissionWebhook) oder Standardeinstellungen (MutatingAdmissionWebhook) über kubebuilder create webhook hinzu.

7. Tests

• Verwenden Sie envtest für Integrationstests, die usw. und kube-apiserver lokal beginnen.
• Schreiben Sie Unit -Tests für Ihre Versöhnungslogik mit fakeclient .

Beispiel -Test -Setup:

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

var Testenv *envTest. -Environment

Grundsätzlich läuft der Bau von Kubernetes -Betreibern in Go auf:

• Definieren einer CRD mit kubebuilder
• Schreiben eines Controllers, der den gewünschten und den tatsächlichen Zustand versöhnt
• Verwenden von controller-runtime , um Kubernetes-Interaktionen zu verarbeiten
• Testen mit envtest und Bereitstellung mit Standardmanifits

Es ist nicht trivial, aber das Werkzeug ist viel gereift-Kubebuilder und Controller-Runtime tun den größten Teil des schweren Hebens. Beginnen Sie klein, automatisieren Sie eine Sache gut und erweitern Sie von dort aus.

Das obige ist der detaillierte Inhalt vonEntwicklung von Kubernetes -Betreibern in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!