Kubebuilder 进阶之源码分析

开发 前端
kubebuilder 帮我们做了很多事情,让我们的开发基本上只需要关注一个 Reconcile 函数就可以了,但是从另外一个方面来讲,kubebuilder 目前对我们来说它还是一个黑盒,会产生很多的疑问.

 [[399769]]

在前面的文章当中我们已经完整的完成了一个 Operator 的开发,涉及到了 CURD、预删除、Status、Event、OwnerReference、WebHook,也算是将一个 Operator 开发中会涉及到的点大部分都了解了一下。kubebuilder 帮我们做了很多事情,让我们的开发基本上只需要关注一个 Reconcile 函数就可以了,但是从另外一个方面来讲,kubebuilder 目前对我们来说它还是一个黑盒,会产生很多的疑问:

  • Reconcile 方法是怎么被触发的?
  • 怎么识别到不同的资源?
  • 整体是如何进行工作的?
  • ……

架构

我们先来看一下来自官方文档的这个架构图[1]

arch

  • Process 进程通过 main.go启动,一般来说一个 Controller 只有一个进程,如果做了高可用的话,会有多个
  • Manager 每个进程会有一个 Manager,这是核心组件,主要负责
    • metrics 的暴露
    • webhook 证书
    • 初始化共享的 cache
    • 初始化共享的 clients 用于和 APIServer 进行通信
    • 所有的 Controller 的运行
  • Client 一般来说,我们 创建、更新、删除某个资源的时候会直接调用 Client 和 APIServer 进行通信
  • Cache 负责同步 Controller 关心的资源,其核心是 GVK -> Informer 的映射,一般我们的 Get 和 List 操作都会从 Cache 中获取数据
  • Controller 控制器的业务逻辑所在的地方,一个 Manager 可能会有多个 Controller,我们一般只需要实现 Reconcile 方法就行。图上的 Predicate 是事件过滤器,我们可以在 Controller 中过滤掉我们不关心的事件信息
  • WebHook 就是我们准入控制实现的地方了,主要是有两类接口,一个是 MutatingAdmissionWebhook 需要实现 Defaulter 接口,一个是 ValidatingAdmissionWebhook 需要实现 Validator 接口

源码分析

了解了基本的架构之后,我们就从入口 main.go 开始,看一看 kubebuilder 究竟在后面偷偷的做了哪些事情吧。

main.go

  1. // 省略了参数绑定和 error check 的代码 
  2. func main() { 
  3.     var metricsAddr string 
  4.     var enableLeaderElection bool 
  5.     var probeAddr string 
  6.  
  7.     ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts))) 
  8.  
  9.     mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ 
  10.         Scheme:                 scheme, 
  11.         MetricsBindAddress:     metricsAddr, 
  12.         Port:                   9443, 
  13.         HealthProbeBindAddress: probeAddr, 
  14.         LeaderElection:         enableLeaderElection, 
  15.         LeaderElectionID:       "97acaccf.lailin.xyz"
  16.         // CertDir:                "config/cert/", // 手动指定证书位置用于测试 
  17.     }) 
  18.      
  19.  
  20.     (&controllers.NodePoolReconciler{ 
  21.         Client:   mgr.GetClient(), 
  22.         Log:      ctrl.Log.WithName("controllers").WithName("NodePool"), 
  23.         Scheme:   mgr.GetScheme(), 
  24.         Recorder: mgr.GetEventRecorderFor("NodePool"), 
  25.     }).SetupWithManager(mgr) 
  26.  
  27.     (&nodesv1.NodePool{}).SetupWebhookWithManager(mgr) 
  28.    
  29.     //+kubebuilder:scaffold:builder 
  30.  
  31.     mgr.AddHealthzCheck("healthz", healthz.Ping) 
  32.     mgr.AddReadyzCheck("readyz", healthz.Ping) 
  33.  
  34.     setupLog.Info("starting manager"
  35.     mgr.Start(ctrl.SetupSignalHandler()) 

可以看到 main.go 主要是做了一些启动的工作包括:

  • 创建一个 Manager
  • 使用刚刚创建的 Manager 创建了一个 Controller
  • 启动 WebHook
  • 添加健康检查
  • 启动 Manager

下面我们就顺着 main 函数里面的逻辑一步步的往下看看

NewManger

  1. // New returns a new Manager for creating Controllers. 
  2. func New(config *rest.Config, options Options) (Manager, error) { 
  3.     // 省略配置初始化相关代码 
  4.  
  5.     // 创建 cache 
  6.     cache, err := options.NewCache(config,  
  7.                                  cache.Options{ 
  8.                                    Scheme: options.Scheme, // main 中传入的 scheme 
  9.                                    Mapper: mapper,         // k8s api 和 go type 的转换器 
  10.                                    Resync: options.SyncPeriod, // 默认 10 小时,一般不要改 
  11.                                    Namespace: options.Namespace, // 需要监听的 namespace 
  12.                                  }) 
  13.  
  14.   // 创建和 APIServer 交互的 client,读写分离 
  15.     clientOptions := client.Options{Scheme: options.Scheme, Mapper: mapper} 
  16.     apiReader, err := client.New(config, clientOptions) 
  17.  
  18.  
  19.     writeObj, err := options.ClientBuilder. 
  20.         WithUncached(options.ClientDisableCacheFor...). 
  21.         Build(cache, config, clientOptions) 
  22.  
  23.     if options.DryRunClient { 
  24.         writeObj = client.NewDryRunClient(writeObj) 
  25.     } 
  26.  
  27.     // 创建事件记录器 
  28.     recorderProvider, err := options.newRecorderProvider(config, options.Scheme, options.Logger.WithName("events"), options.makeBroadcaster) 
  29.  
  30.     // 需要需要高可用的话,创建选举相关的配置 
  31.     leaderConfig := config 
  32.     if options.LeaderElectionConfig != nil { 
  33.         leaderConfig = options.LeaderElectionConfig 
  34.     } 
  35.     resourceLock, err := options.newResourceLock(leaderConfig, recorderProvider, leaderelection.Options{ 
  36.         LeaderElection:             options.LeaderElection, 
  37.         LeaderElectionResourceLock: options.LeaderElectionResourceLock, 
  38.         LeaderElectionID:           options.LeaderElectionID, 
  39.         LeaderElectionNamespace:    options.LeaderElectionNamespace, 
  40.     }) 
  41.  
  42.     // 创建 metric 和 健康检查的接口 
  43.     metricsListener, err := options.newMetricsListener(options.MetricsBindAddress) 
  44.  
  45.     // By default we have no extra endpoints to expose on metrics http server. 
  46.     metricsExtraHandlers := make(map[string]http.Handler) 
  47.  
  48.     // Create health probes listener. This will throw an error if the bind 
  49.     // address is invalid or already in use. 
  50.     healthProbeListener, err := options.newHealthProbeListener(options.HealthProbeBindAddress) 
  51.     if err != nil { 
  52.         return nil, err 
  53.     } 
  54.  
  55.   // 最后将这些配置放到 manager 中 
  56.     return &controllerManager{ 
  57.         config:                  config, 
  58.         scheme:                  options.Scheme, 
  59.         cache:                   cache, 
  60.         fieldIndexes:            cache, 
  61.         client:                  writeObj, 
  62.         apiReader:               apiReader, 
  63.         recorderProvider:        recorderProvider, 
  64.         resourceLock:            resourceLock, 
  65.         mapper:                  mapper, 
  66.         metricsListener:         metricsListener, 
  67.         metricsExtraHandlers:    metricsExtraHandlers, 
  68.         logger:                  options.Logger, 
  69.         elected:                 make(chan struct{}), 
  70.         port:                    options.Port, 
  71.         host:                    options.Host, 
  72.         certDir:                 options.CertDir, 
  73.         leaseDuration:           *options.LeaseDuration, 
  74.         renewDeadline:           *options.RenewDeadline, 
  75.         retryPeriod:             *options.RetryPeriod, 
  76.         healthProbeListener:     healthProbeListener, 
  77.         readinessEndpointName:   options.ReadinessEndpointName, 
  78.         livenessEndpointName:    options.LivenessEndpointName, 
  79.         gracefulShutdownTimeout: *options.GracefulShutdownTimeout, 
  80.         internalProceduresStop:  make(chan struct{}), 
  81.     }, nil 

创建 Cache

  1. func New(config *rest.Config, opts Options) (Cache, error) { 
  2.     opts, err := defaultOpts(config, opts) 
  3.     if err != nil { 
  4.         return nil, err 
  5.     } 
  6.     im := internal.NewInformersMap(config, opts.Scheme, opts.Mapper, *opts.Resync, opts.Namespace) 
  7.     return &informerCache{InformersMap: im}, nil 

这里主要是调用 NewInformersMap方法创建 Informer 的映射

  1. func NewInformersMap(config *rest.Config, 
  2.     scheme *runtime.Scheme, 
  3.     mapper meta.RESTMapper, 
  4.     resync time.Duration, 
  5.     namespace string) *InformersMap { 
  6.  
  7.     return &InformersMap{ 
  8.         structured:   newStructuredInformersMap(config, scheme, mapper, resync, namespace), 
  9.         unstructured: newUnstructuredInformersMap(config, scheme, mapper, resync, namespace), 
  10.         metadata:     newMetadataInformersMap(config, scheme, mapper, resync, namespace), 
  11.  
  12.         Scheme: scheme, 
  13.     } 

NewInformersMap会去分别创建,结构化、非结构化以及 metadata 的 InformerMap 而这些方法最后都会去调用 newSpecificInformersMap方法,区别就是不同的方法传入的 createListWatcherFunc 参数不同

  1. func newSpecificInformersMap(config *rest.Config, 
  2.     scheme *runtime.Scheme, 
  3.     mapper meta.RESTMapper, 
  4.     resync time.Duration, 
  5.     namespace string, 
  6.     createListWatcher createListWatcherFunc) *specificInformersMap { 
  7.     ip := &specificInformersMap{ 
  8.         config:            config, 
  9.         Scheme:            scheme, 
  10.         mapper:            mapper, 
  11.         informersByGVK:    make(map[schema.GroupVersionKind]*MapEntry), 
  12.         codecs:            serializer.NewCodecFactory(scheme), 
  13.         paramCodec:        runtime.NewParameterCodec(scheme), 
  14.         resync:            resync, 
  15.         startWait:         make(chan struct{}), 
  16.         createListWatcher: createListWatcher, 
  17.         namespace:         namespace, 
  18.     } 
  19.     return ip 

newSpecificInformersMap 和常规的 InformersMap 类似,区别是没实现 WaitForCacheSync方法

以结构化的传入的 createStructuredListWatch 为例,主要是返回一个用于创建 SharedIndexInformer 的 ListWatch 对象

  1. func createStructuredListWatch(gvk schema.GroupVersionKind, ip *specificInformersMap) (*cache.ListWatch, error) { 
  2.  // Kubernetes APIs work against Resources, not GroupVersionKinds.  Map the 
  3.  // groupVersionKind to the Resource API we will use. 
  4.  mapping, err := ip.mapper.RESTMapping(gvk.GroupKind(), gvk.Version) 
  5.  if err != nil { 
  6.   return nil, err 
  7.  } 
  8.  
  9.  client, err := apiutil.RESTClientForGVK(gvk, false, ip.config, ip.codecs) 
  10.  if err != nil { 
  11.   return nil, err 
  12.  } 
  13.  listGVK := gvk.GroupVersion().WithKind(gvk.Kind + "List"
  14.  listObj, err := ip.Scheme.New(listGVK) 
  15.  if err != nil { 
  16.   return nil, err 
  17.  } 
  18.  
  19.  // TODO: the functions that make use of this ListWatch should be adapted to 
  20.  //  pass in their own contexts instead of relying on this fixed one here. 
  21.  ctx := context.TODO() 
  22.  // Create a new ListWatch for the obj 
  23.  return &cache.ListWatch{ 
  24.   ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) { 
  25.    res := listObj.DeepCopyObject() 
  26.    isNamespaceScoped := ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot 
  27.    err := client.Get().NamespaceIfScoped(ip.namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Do(ctx).Into(res) 
  28.    return res, err 
  29.   }, 
  30.   // Setup the watch function 
  31.   WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) { 
  32.    // Watch needs to be set to true separately 
  33.    opts.Watch = true 
  34.    isNamespaceScoped := ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot 
  35.    return client.Get().NamespaceIfScoped(ip.namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Watch(ctx) 
  36.   }, 
  37.  }, nil 

小结: cache 主要是创建了一些 InformerMap,完成了 GVK 到 Informer 的映射,每个 Informer 会根据 ListWatch 函数对对应的 GVK 进行 List 和 Watch。

创建 Client

  1. func New(config *rest.Config, options Options) (Client, error) { 
  2.  if config == nil { 
  3.   return nil, fmt.Errorf("must provide non-nil rest.Config to client.New"
  4.  } 
  5.  
  6.  // Init a scheme if none provided 
  7.  if options.Scheme == nil { 
  8.   options.Scheme = scheme.Scheme 
  9.  } 
  10.  
  11.  // Init a Mapper if none provided 
  12.  if options.Mapper == nil { 
  13.   var err error 
  14.   options.Mapper, err = apiutil.NewDynamicRESTMapper(config) 
  15.   if err != nil { 
  16.    return nil, err 
  17.   } 
  18.  } 
  19.  
  20.  clientcache := &clientCache{ 
  21.   config: config, 
  22.   scheme: options.Scheme, 
  23.   mapper: options.Mapper, 
  24.   codecs: serializer.NewCodecFactory(options.Scheme), 
  25.  
  26.   structuredResourceByType:   make(map[schema.GroupVersionKind]*resourceMeta), 
  27.   unstructuredResourceByType: make(map[schema.GroupVersionKind]*resourceMeta), 
  28.  } 
  29.  
  30.  rawMetaClient, err := metadata.NewForConfig(config) 
  31.  if err != nil { 
  32.   return nil, fmt.Errorf("unable to construct metadata-only client for use as part of client: %w", err) 
  33.  } 
  34.  
  35.  c := &client{ 
  36.   typedClient: typedClient{ 
  37.    cache:      clientcache, 
  38.    paramCodec: runtime.NewParameterCodec(options.Scheme), 
  39.   }, 
  40.   unstructuredClient: unstructuredClient{ 
  41.    cache:      clientcache, 
  42.    paramCodec: noConversionParamCodec{}, 
  43.   }, 
  44.   metadataClient: metadataClient{ 
  45.    client:     rawMetaClient, 
  46.    restMapper: options.Mapper, 
  47.   }, 
  48.   scheme: options.Scheme, 
  49.   mapper: options.Mapper, 
  50.  } 
  51.  
  52.  return c, nil 

client 创建了两个一个用于读,一个用于写,用于读的会直接使用上面的 cache,用于写的才会直接和 APIServer 进行交互

Controller

下面我们看一下核心的 Controller 是怎么初始化和工作的

  1. if err = (&controllers.NodePoolReconciler{ 
  2.   Client:   mgr.GetClient(), 
  3.   Log:      ctrl.Log.WithName("controllers").WithName("NodePool"), 
  4.   Scheme:   mgr.GetScheme(), 
  5.   Recorder: mgr.GetEventRecorderFor("NodePool"), 
  6. }).SetupWithManager(mgr); err != nil { 
  7.   setupLog.Error(err, "unable to create controller""controller""NodePool"
  8.   os.Exit(1) 

main.go 的方法里面主要是初始化了 Controller 的结构体,然后调用了 SetupWithManager方法

  1. // SetupWithManager sets up the controller with the Manager. 
  2. func (r *NodePoolReconciler) SetupWithManager(mgr ctrl.Manager) error { 
  3.     return ctrl.NewControllerManagedBy(mgr). 
  4.         For(&nodesv1.NodePool{}). 
  5.         Watches(&source.Kind{Type: &corev1.Node{}}, handler.Funcs{UpdateFunc: r.nodeUpdateHandler}). 
  6.         Complete(r) 

SetupWithManager之前有讲到过,主要是使用了建造者模式,去构建了我们需要监听的对象,只有这些对象的相关事件才会触发我们的 Reconcile 逻辑。这里面的 Complete 最后其实是调用了 Build 方法

  1. func (blder *Builder) Build(r reconcile.Reconciler) (controller.Controller, error) { 
  2.     // 省略参数校验 
  3.  
  4.     // Set the Config 
  5.     blder.loadRestConfig() 
  6.  
  7.     // Set the ControllerManagedBy 
  8.     if err := blder.doController(r); err != nil { 
  9.         return nil, err 
  10.     } 
  11.  
  12.     // Set the Watch 
  13.     if err := blder.doWatch(); err != nil { 
  14.         return nil, err 
  15.     } 
  16.  
  17.     return blder.ctrl, nil 

Build主要调用 doController 、doWatch两个方法

  1. func (blder *Builder) doController(r reconcile.Reconciler) error { 
  2.     ctrlOptions := blder.ctrlOptions 
  3.     if ctrlOptions.Reconciler == nil { 
  4.         ctrlOptions.Reconciler = r 
  5.     } 
  6.  
  7.     // Retrieve the GVK from the object we're reconciling 
  8.     // to prepopulate logger information, and to optionally generate a default name
  9.     gvk, err := getGvk(blder.forInput.object, blder.mgr.GetScheme()) 
  10.     if err != nil { 
  11.         return err 
  12.     } 
  13.  
  14.     // Setup the logger. 
  15.     if ctrlOptions.Log == nil { 
  16.         ctrlOptions.Log = blder.mgr.GetLogger() 
  17.     } 
  18.     ctrlOptions.Log = ctrlOptions.Log.WithValues("reconciler group", gvk.Group"reconciler kind", gvk.Kind) 
  19.  
  20.     // Build the controller and return
  21.     blder.ctrl, err = newController(blder.getControllerName(gvk), blder.mgr, ctrlOptions) 
  22.     return err 

doController主要是初始化了一个 Controller,这里面传入了我们实现 的Reconciler以及获取到我们的 GVK 的名称

  1. func (blder *Builder) doWatch() error { 
  2.     // Reconcile type 
  3.     typeForSrc, err := blder.project(blder.forInput.object, blder.forInput.objectProjection) 
  4.     if err != nil { 
  5.         return err 
  6.     } 
  7.     src := &source.Kind{Type: typeForSrc} 
  8.     hdler := &handler.EnqueueRequestForObject{} 
  9.     allPredicates := append(blder.globalPredicates, blder.forInput.predicates...) 
  10.     if err := blder.ctrl.Watch(src, hdler, allPredicates...); err != nil { 
  11.         return err 
  12.     } 
  13.  
  14.     // Watches the managed types 
  15.     for _, own := range blder.ownsInput { 
  16.         typeForSrc, err := blder.project(own.object, own.objectProjection) 
  17.         if err != nil { 
  18.             return err 
  19.         } 
  20.         src := &source.Kind{Type: typeForSrc} 
  21.         hdler := &handler.EnqueueRequestForOwner{ 
  22.             OwnerType:    blder.forInput.object, 
  23.             IsController: true
  24.         } 
  25.         allPredicates := append([]predicate.Predicate(nil), blder.globalPredicates...) 
  26.         allPredicates = append(allPredicates, own.predicates...) 
  27.         if err := blder.ctrl.Watch(src, hdler, allPredicates...); err != nil { 
  28.             return err 
  29.         } 
  30.     } 
  31.  
  32.     // Do the watch requests 
  33.     for _, w := range blder.watchesInput { 
  34.         allPredicates := append([]predicate.Predicate(nil), blder.globalPredicates...) 
  35.         allPredicates = append(allPredicates, w.predicates...) 
  36.  
  37.         // If the source of this watch is of type *source.Kind, project it. 
  38.         if srckind, ok := w.src.(*source.Kind); ok { 
  39.             typeForSrc, err := blder.project(srckind.Type, w.objectProjection) 
  40.             if err != nil { 
  41.                 return err 
  42.             } 
  43.             srckind.Type = typeForSrc 
  44.         } 
  45.  
  46.         if err := blder.ctrl.Watch(w.src, w.eventhandler, allPredicates...); err != nil { 
  47.             return err 
  48.         } 
  49.     } 
  50.     return nil 

Watch 主要是监听我们想要的资源变化,blder.ctrl.Watch(src, hdler, allPredicates...)通过过滤源事件的变化,allPredicates是过滤器,只有所有的过滤器都返回 true 时,才会将事件传递给 EventHandler hdler,这里会将 Handler 注册到 Informer 上

启动

  1. func (cm *controllerManager) Start(ctx context.Context) (err error) { 
  2.     cm.internalCtx, cm.internalCancel = context.WithCancel(ctx) 
  3.  
  4.     // 这个用来表示所有的协程都已经退出了, 
  5.     stopComplete := make(chan struct{}) 
  6.     defer close(stopComplete) 
  7.      
  8.   // ...... 
  9.  
  10.     // 用于保存错误 
  11.     cm.errChan = make(chan error) 
  12.  
  13.     // 如果需要 metric 就启动 metric 服务 
  14.     if cm.metricsListener != nil { 
  15.         go cm.serveMetrics() 
  16.     } 
  17.  
  18.     // 启动健康检查服务 
  19.     if cm.healthProbeListener != nil { 
  20.         go cm.serveHealthProbes() 
  21.     } 
  22.  
  23.    
  24.     go cm.startNonLeaderElectionRunnables() 
  25.  
  26.     go func() { 
  27.         if cm.resourceLock != nil { 
  28.             err := cm.startLeaderElection() 
  29.             if err != nil { 
  30.                 cm.errChan <- err 
  31.             } 
  32.         } else { 
  33.             // Treat not having leader election enabled the same as being elected. 
  34.             close(cm.elected) 
  35.             go cm.startLeaderElectionRunnables() 
  36.         } 
  37.     }() 
  38.  
  39.   // 判断是否需要退出 
  40.     select { 
  41.     case <-ctx.Done(): 
  42.         // We are done 
  43.         return nil 
  44.     case err := <-cm.errChan: 
  45.         // Error starting or running a runnable 
  46.         return err 
  47.     } 

无论是不是 leader 最后都会使用 startRunnable 启动 Controller

  1. func (cm *controllerManager) startNonLeaderElectionRunnables() { 
  2.     cm.mu.Lock() 
  3.     defer cm.mu.Unlock() 
  4.  
  5.     cm.waitForCache(cm.internalCtx) 
  6.  
  7.     // Start the non-leaderelection Runnables after the cache has synced 
  8.     for _, c := range cm.nonLeaderElectionRunnables { 
  9.         // Controllers block, but we want to return an error if any have an error starting. 
  10.         // Write any Start errors to a channel so we can return them 
  11.         cm.startRunnable(c) 
  12.     } 

实际上是调用了 Controller 的 Start方法

  1. // Start implements controller.Controller 
  2. func (c *Controller) Start(ctx context.Context) error { 
  3.  
  4.   // Controller 只能被执行一次 
  5.     c.mu.Lock() 
  6.     if c.Started { 
  7.         return errors.New("controller was started more than once. This is likely to be caused by being added to a manager multiple times"
  8.     } 
  9.  
  10.     // Set the internal context. 
  11.     c.ctx = ctx 
  12.  
  13.   // 获取队列 
  14.     c.Queue = c.MakeQueue() 
  15.     defer c.Queue.ShutDown() 
  16.  
  17.     err := func() error { 
  18.         defer c.mu.Unlock() 
  19.  
  20.         defer utilruntime.HandleCrash() 
  21.  
  22.         // 尝试等待缓存 
  23.         for _, watch := range c.startWatches { 
  24.             c.Log.Info("Starting EventSource""source", watch.src) 
  25.             if err := watch.src.Start(ctx, watch.handler, c.Queue, watch.predicates...); err != nil { 
  26.                 return err 
  27.             } 
  28.         } 
  29.  
  30.         // 启动 Controller 
  31.         c.Log.Info("Starting Controller"
  32.  
  33.      
  34.         for _, watch := range c.startWatches { 
  35.             syncingSource, ok := watch.src.(source.SyncingSource) 
  36.             if !ok { 
  37.                 continue 
  38.             } 
  39.             if err := syncingSource.WaitForSync(ctx); err != nil { 
  40.                 // This code is unreachable in case of kube watches since WaitForCacheSync will never return an error 
  41.                 // Leaving it here because that could happen in the future 
  42.                 err := fmt.Errorf("failed to wait for %s caches to sync: %w", c.Name, err) 
  43.                 c.Log.Error(err, "Could not wait for Cache to sync"
  44.                 return err 
  45.             } 
  46.         } 
  47.  
  48.         // All the watches have been started, we can reset the local slice. 
  49.         // 
  50.         // We should never hold watches more than necessary, each watch source can hold a backing cache, 
  51.         // which won't be garbage collected if we hold a reference to it. 
  52.         c.startWatches = nil 
  53.  
  54.         if c.JitterPeriod == 0 { 
  55.             c.JitterPeriod = 1 * time.Second 
  56.         } 
  57.  
  58.         // Launch workers to process resources 
  59.         c.Log.Info("Starting workers""worker count", c.MaxConcurrentReconciles) 
  60.         ctrlmetrics.WorkerCount.WithLabelValues(c.Name). 
  61.                     Set(float64(c.MaxConcurrentReconciles)) 
  62.         for i := 0; i < c.MaxConcurrentReconciles; i++ { 
  63.             go wait.UntilWithContext(ctx, func(ctx context.Context) { 
  64.                 // 查询队列中有没有关注的事件,有的话就触发我们的 reconcile 逻辑 
  65.                 for c.processNextWorkItem(ctx) { 
  66.                 } 
  67.             }, c.JitterPeriod) 
  68.         } 
  69.  
  70.         c.Started = true 
  71.         return nil 
  72.     }() 
  73.     if err != nil { 
  74.         return err 
  75.     } 
  76.  
  77.     <-ctx.Done() 
  78.     c.Log.Info("Stopping workers"
  79.     return nil 
  80.  
  81. // attempt to process it, by calling the reconcileHandler. 
  82. func (c *Controller) processNextWorkItem(ctx context.Context) bool { 
  83.     obj, shutdown := c.Queue.Get() 
  84.     if shutdown { 
  85.         // Stop working 
  86.         return false 
  87.     } 
  88.  
  89.     // We call Done here so the workqueue knows we have finished 
  90.     // processing this item. We also must remember to call Forget if we 
  91.     // do not want this work item being re-queued. For example, we do 
  92.     // not call Forget if a transient error occurs, instead the item is 
  93.     // put back on the workqueue and attempted again after a back-off 
  94.     // period. 
  95.     defer c.Queue.Done(obj) 
  96.  
  97.     ctrlmetrics.ActiveWorkers.WithLabelValues(c.Name).Add(1) 
  98.     defer ctrlmetrics.ActiveWorkers.WithLabelValues(c.Name).Add(-1) 
  99.  
  100.     c.reconcileHandler(ctx, obj) 
  101.     return true 

总结

Reconcile 方法的触发是通过 Cache 中的 Informer 获取到资源的变更事件,然后再通过生产者消费者的模式触发我们自己实现的 Reconcile 方法的。

Kubebuilder 是一个非常好用的 Operator 开发框架,不仅极大的简化了 Operator 的开发过程,并且充分的利用了 go interface 的特性留下了足够的扩展性,这个我们可以学习,如果我们的业务代码开发框架能够做到这个地步,我觉得也就不错了

参考文献

架构图 https://master.book.kubebuilder.io/architecture.html?

本文转载自微信公众号「mohuishou」,可以通过以下二维码关注。转载本文请联系mohuishou公众号。

原文链接:https://lailin.xyz/post/operator-09-kubebuilder-code.html

 

责任编辑:武晓燕 来源: mohuishou博客
相关推荐

2016-09-22 15:50:38

JavascriptRedux源码解析

2021-09-26 08:35:17

Android控件宽高

2019-12-23 09:13:11

Python数据语言

2021-05-18 05:40:27

kubebuilderwebhook进阶

2021-05-17 05:51:31

KubeBuilderOperator测试

2021-09-05 07:35:58

lifecycleAndroid组件原理

2011-03-23 10:30:01

LAMPApache源码

2022-04-06 14:55:45

Harmony同步机制鸿蒙

2021-05-12 06:18:19

KubeBuilderOperatork8s

2021-08-28 07:48:04

AndroidActivityRecActivitySta

2016-12-09 19:21:14

2021-09-02 07:00:01

Glide流程Android

2021-10-20 07:18:50

开源轻量级缓存

2021-05-16 10:52:58

kubebuilderstatus event

2014-08-26 11:11:57

AsyncHttpCl源码分析

2011-03-15 11:33:18

iptables

2021-08-12 16:28:10

AndroidHandleLooper

2021-09-05 17:22:08

Strview.js工具js

2015-09-22 10:30:20

创新之源大会

2011-05-26 10:05:48

MongoDB
点赞
收藏

51CTO技术栈公众号