Comment surveiller les modifications des ressources personnalisées externes dans Kubebuilder sans importer de types externes

Contenu de la question

Supposons que j'ai l'extrait de code suivant, qui configure un coordinateur qui surveille une ressource externe "externe" :

// SetupWithManager sets up the controller with the Manager.
func (r *SomethingReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&api.Something{}).
        WithOptions(controller.Options{
            MaxConcurrentReconciles: stdruntime.NumCPU(),
            RecoverPanic:            true,
        }).
        Watches(
            &source.Kind{Type: &somev1.External{}},
            handler.EnqueueRequestsFromMapFunc(r.findInternalObjectsForExternal),
            builder.WithPredicates(predicate.Funcs{
                UpdateFunc: func(ue event.UpdateEvent) bool { return true },
                DeleteFunc: func(de event.DeleteEvent) bool { return true },
            }),
        ).
        Complete(r)
}

Mon problème est que je ne peux pas importer le type somev1.external dans mon projet car importer un module go contenant ce type briserait les dépendances de mon projet actuel.

Existe-t-il un moyen dans Kubebuilder de surveiller les ressources externes sans importer explicitement leurs types ? Comme gvk ou quelque chose comme ça ?

Bonne réponse

Oui, c'est possible.

Vous pouvez créer un client de repos pour votre ressource dans main.go comme ceci :

gvkexternal := schema.groupversionkind{
    group:   "some.group.io",
    version: "v1",
    kind:    "external",
}

restclient, err := apiutil.restclientforgvk(gvkexternal, false, mgr.getconfig(), serializer.newcodecfactory(mgr.getscheme()))
if err != nil {
    setuplog.error(err, "unable to create rest client")
}

Puis mettez cette structure reste client (rest.interface) 的字段添加到您的协调器 (yournativeresource_controller.go), par exemple :

type yournativeresourcereconciler struct {
    client.client
    scheme        *runtime.scheme
    // add this
    restclient    rest.interface
}

Enfin, initialisez votre coordinateur à l'aide de ce client de repos (main.go) :

if err = (&controllers.yournativeresourcereconciler{
    client:        mgr.getclient(),
    scheme:        mgr.getscheme(),
    restclient:    restclient,
}).setupwithmanager(mgr); err != nil {
    setuplog.error(err, "unable to create controller", "controller", "yournativeresource")
    os.exit(1)
}

N'oubliez pas d'ajouter le tag rbac à votre projet (le coordinateur de préférence), il générera des règles rbac vous permettant de fonctionner external Ressources :

//+kubebuilder:rbac:groups=some.group.io,resources=externals,verbs=get;list;watch;create;update;patch;delete

Après avoir terminé ces étapes, vous pouvez utiliser le client rest via le coordinateur yournativeresource (utilisez r.restclient pour manipuler la ressource yournativeresource 协调器（使用 r.restclient 来操作 external.

)

Éditeur :

Si vous souhaitez regarder des sources, un client dynamique peut être utile. Créez un client dynamique dans main.go :

dynamicclient, err := dynamic.newforconfig(mgr.getconfig())
if err != nil {
    setuplog.error(err, "unable to create dynamic client")
}

Appliquez les étapes ci-dessus, ajoutez-le à votre coordinateur, etc. Vous pourrez alors regarder la external ressource comme indiqué ci-dessous :

resourceInterface := r.DynamicClient.Resource(schema.GroupVersionResource{
    Group:    "some.group.io",
    Version:  "",
    Resource: "externals",
})
externalWatcher, err := resourceInterface.Watch(ctx, metav1.ListOptions{})
if err != nil {
    return err
}

defer externalWatcher.Stop()

select {
case event := <-externalWatcher.ResultChan():
    if event.Type == watch.Deleted {
        logger.Info("FINALIZER: An external resource is deleted.")
    }
}

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!