La fa?on la plus efficace d'écrire un opérateur de Kubernetes est d'utiliser GO pour combiner kubebuilder et contr?leur-runtime. 1. Comprendre le modèle de l'opérateur: définir les ressources personnalisées via CRD, écrivez un contr?leur pour écouter les changements de ressources et effectuer des boucles de réconciliation pour maintenir l'état attendu. 2. Initialisez le projet avec KubeBuilder et créez des API pour générer automatiquement les CRD, les contr?leurs et les fichiers de configuration. 3. Définissez les structures de spécification et d'état de CRD dans API / V1 / MYAPP_TYPES.go et exécutez les manifestes pour générer CRD YAML. 4. Implémentez la logique métier dans la méthode de réconciliation du contr?leur et utilisez R.Create, R.update et d'autres méthodes pour gérer les ressources Kubernetes. 5. Définir les autorisations RBAC via des annotations GO, construire des images à l'aide de manifestes et de faire docker-build, et de les déployer via Kubectl ou de déployer. 6. Suivez les meilleures pratiques: assurez-vous la réconciliation de l'idémpotence logique, gérez les erreurs raisonnablement et utilisez la demande pour contr?ler la réessayer, ajouter des journaux et des événements, et utilisez les finaliseurs et les webhooks si nécessaire. 7. Utiliser EnvTest pour les tests d'intégration et FAKECLIENT pour les tests unitaires. En fin de compte, le c?ur du développement de l'opérateur est de définir le CRD, d'écrire une logique harmonique, d'utiliser le contr?leur-runtime pour simplifier l'interaction K8S et de terminer les tests et le déploiement via des cha?nes d'outils matures.

La rédaction des opérateurs de Kubernetes en Go est l'un des moyens les plus efficaces d'étendre le plan de contr?le de Kubernetes pour gérer des applications complexes et avec état. Un opérateur utilise des ressources personnalisées (CRS) et des contr?leurs pour automatiser les taches qu'un opérateur humain effectuerait autrement, comme les sauvegardes, la mise à l'échelle, les mises à niveau et le basculement. GO est le choix naturel car Kubernetes lui-même est écrit en Go, et l'écosystème (comme le client-go et le contr?leur-runtime) est mature et bien documenté.

Voici un guide pratique pour vous aider à démarrer et à comprendre les composants clés.

1. Comprendre le modèle de l'opérateur

Un opérateur combine une définition de ressources personnalisées (CRD) avec un contr?leur qui regarde des modifications de cette ressource et agir pour concilier l'état souhaité avec l'état réel du cluster.

• Ressource personnalisée (CR) : un YAML manifeste définissant l'état souhaité de votre application (par exemple, MyAppDatabase ).
• Contr?leur : un programme GO qui regarde les objets MyAppDatabase et gère les ressources Kubernetes (par exemple, StatefulSets, Services) pour correspondre à la spécification.

Ceci est basé sur la boucle d'informateurs et de réconciliation .

2. Utilisez KubeBuilder et Controller-Runtime

Le moyen le plus simple de construire un opérateur en Go est de l'utilisation de KubeBuilder , qui fait partie des Sigs Kubernetes, qui échafolds des projets utilisant le contr?leur-runtime - une bibliothèque qui gère les détails de bas niveau comme la configuration du client, la gestion des événements et la réconciliation.

Outils d'installation:

 # Installer 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
Export Path = $ path: / usr / local / kubebuilder / bin

Créer un nouveau projet:

 MKDIR MYAPP-OPERATEUR
CD MyApp-opérateur
Kubebuilder init --domain example.com --repo example.com/myapp-operator
kubebuilder Créer des applications API - GROUP --version v1 - kind myApp

Cela génère:

• api/v1/myapp_types.go - définissez votre schéma CRD.
• controllers/myapp_controller.go - où vous écrivez la logique de réconciliation.
• config/ - Kustomalize Manifests pour le déploiement de CRD et RBAC.

3. Définissez votre ressource personnalisée

Modifier api/v1/myapp_types.go :

 Tapez myAppSpec Struct {
    Répliques int32 `json:" répliques "`
    String d'image `json:" image "`
    Port int32 `json:" port "`
}

Tapez MyAppstatus Struct {
    ReadyReplicas int32 `JSON:" ReadyReplicas "`
    Conditions [] metav1.condition `JSON:" Conditions, omitempty "`
}

Run make manifests pour générer CRD YAML à partir des annotations Go.

4. Implémentez la logique de réconciliation

Dans controllers/myapp_controller.go , la méthode Reconcile est appelée chaque fois qu'une ressource MyApp change.

 func (r * myappreconciler) reconciler (ctx context.context, req ctrl.request) (ctrl.result, error) {
    Log: = R.Log.WithValues ("MyApp", req.NamespacedName)

    var myapp myapp
    Si err: = r.get (ctx, req.NamespacedName, & myApp); err! = Nil {
        return ctrl.result {}, client.ignoreNotFound (err)
    }

    // s'assurer qu'un déploiement existe
    DESIREDDEP: = & appsv1.Deployment {
        ObjectMeta: metav1.objectmeta {
            Nom: MyApp.name,
            Espace de noms: myApp.Namespace,
        },
        Spec: appsv1.DeploymentsPec {
            Répliques: & myapp.spec.replicas,
            Sélecteur: & metav1.LabelSelector {
                MatchLabels: Map [String] String {"App": MyApp.name},
            },
            Modèle: corev1.podTemplateSpec {
                ObjectMeta: metav1.objectmeta {
                    Labels: map [String] String {"app": myApp.name},
                },
                Spec: corev1.podspec {
                    Conteneurs: [] corev1.Container {
                        {
                            Nom: "App",
                            Image: myApp.spec.image,
                            Ports: [] corev1.contiainerport {{contenerport: myapp.spe.port}},
                        },
                    },
                },
            },
        },
    }

    // Utilisez le client de Controller-Runtime pour créer ou mettre à jour
    Si err: = r.create (ctx, désiré); err! = Nil {
        si! errors.isalreadyExists (err) {
            return ctrl.result {}, err
        }
    }

    // Statut de mise à jour
    myApp.status.readyReplicas = 0 // Mise à jour du déploiement réel
    Si err: = r.status (). Update (ctx, & myApp); err! = Nil {
        return ctrl.result {}, err
    }

    return ctrl.result {}, nil
}

Utilisez r.Create , r.Update , r.Patch ou r.Delete pour gérer les objets.

5. Ajouter le RBAC et déployer

KubeBuilder utilise des annotations GO pour générer des règles RBAC:

 // KubeBuilder: RBAC: groupes = apps.example.com, ressources = myapps, verbes = get; list; watch; créer; mise à jour; patch; supprimer
// KubeBuilder: RBAC: groupes = applications, ressources = déploiements, verbes = get; list; watch; créer; mise à jour; patch; supprimer
// kubebuilder: RBAC: groupes = noyau, ressources = pods, verbes = liste

Courir:

 Faire des manifestes
faire docker-build img = myapp-opérateur: v0.0.1
kubectl appliquer -f config / crd / bases / apps.example.com_myapps.yaml
Kubectl Créer un déploiement MyApp-Operator --image = MyApp-Operator: V0.0.1

Ou utilisez make deploy IMG=myapp-operator:v0.0.1 Si vous utilisez la configuration Kustomze par défaut.

6. meilleures pratiques

• Idempotence : les boucles de réconciliation peuvent s'exécuter plusieurs fois - les opérations d'insurpation sont s?res à répéter.
• Gestion des erreurs : retourner les erreurs à demander; Utilisez ctrl.Result{RequeueAfter: time.Second} pour les vérifications périodiques.
• Journalisation et événements : utilisez r.Log et r.Recorder.Event() pour émettre des événements Kubernetes.
• Finaliseurs : utilisez-les lorsque vous devez effectuer un nettoyage avant la suppression d'un CR.
• WebHooks : Ajouter une validation (validerAdmissionWebHook) ou par défaut (MutatingAdmissionWebhook) via kubebuilder create webhook .

7. Test

• Utilisez envtest pour les tests d'intégration qui commencent ETCD et KUBE-apiserver localement.
• écrivez des tests unitaires pour votre logique de réconciliation à l'aide fakeclient .

Exemple de configuration de test:

 importer (
    "Sigs.k8s.io/Controller-Runtime/pkg/envtest"
)

var testenv * Envtest.environment

Fondamentalement, la construction des opérateurs de Kubernetes en Go se résume à:

• Définir un CRD avec kubebuilder
• Rédaction d'un contr?leur qui réconcilise souhaité par rapport à l'état réel
• Utilisation controller-runtime pour gérer les interactions Kubernetes
• Tester avec envtest et se déploier avec des manifestes standard

Ce n'est pas trivial, mais l'outillage a beaucoup m?ri - le kubebuilder et le contr?leur-runtime font la plupart des lourds levage. Commencez petit, automatisant bien une chose et développez à partir de là.

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!