Golang笔记-11-controller-runtime

 1func main() {
 2	entryLog := log.Log.WithName("entrypoint")
 3
 4	// 创建一个manager
 5	entryLog.Info("setting up manager")
 6	mgr, err := manager.New(config.GetConfigOrDie(), manager.Options{})
 7	if err != nil {
 8		entryLog.Error(err, "unable to set up overall controller manager")
 9		os.Exit(1)
10	}
11
12	// 创建一个controller来同步pod
13	entryLog.Info("Setting up controller")
14	c, err := controller.New("pod-controller", mgr, controller.Options{
15		Reconciler: &reconcilePod{client: mgr.GetClient()},
16	})
17	if err != nil {
18		entryLog.Error(err, "unable to set up individual controller")
19		os.Exit(1)
20	}
21
22	// 监控Pod变动并将key写入workqueue
23	if err := c.Watch(&source.Kind{Type: &corev1.Pod{}}, &handler.EnqueueRequestForObject{}); err != nil {
24		entryLog.Error(err, "unable to watch Pod")
25		os.Exit(1)
26	}
27
28	// 启动manager
29	entryLog.Info("starting manager")
30	if err := mgr.Start(signals.SetupSignalHandler()); err != nil {
31		entryLog.Error(err, "unable to run manager")
32		os.Exit(1)
33	}
34}
35
36type reconcilePod struct {
37	// client 用于从APIServer获取资源对象
38	client client.Client
39}
40
41// 检查自定义控制器是否实现Reconcile方法
42var _ reconcile.Reconciler = &reconcilePod{}
43
44func (r *reconcilePod) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
45	// 初始化log
46	log := log.FromContext(ctx)
47
48	// 从缓存中获取Pod
49	pod := &corev1.Pod{}
50	err := r.client.Get(ctx, request.NamespacedName, rs)
51	if errors.IsNotFound(err) {
52		log.Error(nil, "Could not find Pod")
53		return reconcile.Result{}, nil
54	}
55
56	if err != nil {
57		return reconcile.Result{}, fmt.Errorf("could not fetch Pod: %+v", err)
58	}
59
60	// 打印Pod
61	log.Info("Reconciling Pod", "pod name", pod.Name)
62
63	return reconcile.Result{}, nil
64}

 1// Manager initializes shared dependencies such as Caches and Clients, and provides them to Runnables.
 2// A Manager is required to create Controllers.
 3type Manager interface {
 4	// Cluster holds a variety of methods to interact with a cluster.
 5	cluster.Cluster
 6
 7	// Add will set requested dependencies on the component, and cause the component to be
 8	// started when Start is called.  Add will inject any dependencies for which the argument
 9	// implements the inject interface - e.g. inject.Client.
10	// Depending on if a Runnable implements LeaderElectionRunnable interface, a Runnable can be run in either
11	// non-leaderelection mode (always running) or leader election mode (managed by leader election if enabled).
12	Add(Runnable) error
13
14	// Elected is closed when this manager is elected leader of a group of
15	// managers, either because it won a leader election or because no leader
16	// election was configured.
17	Elected() <-chan struct{}
18
19	// AddMetricsExtraHandler adds an extra handler served on path to the http server that serves metrics.
20	// Might be useful to register some diagnostic endpoints e.g. pprof. Note that these endpoints meant to be
21	// sensitive and shouldn't be exposed publicly.
22	// If the simple path -> handler mapping offered here is not enough, a new http server/listener should be added as
23	// Runnable to the manager via Add method.
24	AddMetricsExtraHandler(path string, handler http.Handler) error
25
26	// AddHealthzCheck allows you to add Healthz checker
27	AddHealthzCheck(name string, check healthz.Checker) error
28
29	// AddReadyzCheck allows you to add Readyz checker
30	AddReadyzCheck(name string, check healthz.Checker) error
31
32	// Start starts all registered Controllers and blocks until the context is cancelled.
33	// Returns an error if there is an error starting any controller.
34	//
35	// If LeaderElection is used, the binary must be exited immediately after this returns,
36	// otherwise components that need leader election might continue to run after the leader
37	// lock was lost.
38	Start(ctx context.Context) error
39
40	// GetWebhookServer returns a webhook.Server
41	GetWebhookServer() *webhook.Server
42
43	// GetLogger returns this manager's logger.
44	GetLogger() logr.Logger
45
46	// GetControllerOptions returns controller global configuration options.
47	GetControllerOptions() v1alpha1.ControllerConfigurationSpec
48}

 1// Cluster provides various methods to interact with a cluster.
 2type Cluster interface {
 3	// SetFields will set any dependencies on an object for which the object has implemented the inject
 4	// interface - e.g. inject.Client.
 5	// Deprecated: use the equivalent Options field to set a field. This method will be removed in v0.10.
 6	SetFields(interface{}) error
 7
 8	// GetConfig returns an initialized Config
 9	GetConfig() *rest.Config
10
11	// GetScheme returns an initialized Scheme
12	GetScheme() *runtime.Scheme
13
14	// GetClient returns a client configured with the Config. This client may
15	// not be a fully "direct" client -- it may read from a cache, for
16	// instance.  See Options.NewClient for more information on how the default
17	// implementation works.
18	GetClient() client.Client
19
20	// GetFieldIndexer returns a client.FieldIndexer configured with the client
21	GetFieldIndexer() client.FieldIndexer
22
23	// GetCache returns a cache.Cache
24	GetCache() cache.Cache
25
26	// GetEventRecorderFor returns a new EventRecorder for the provided name
27	GetEventRecorderFor(name string) record.EventRecorder
28
29	// GetRESTMapper returns a RESTMapper
30	GetRESTMapper() meta.RESTMapper
31
32	// GetAPIReader returns a reader that will be configured to use the API server.
33	// This should be used sparingly and only when the client does not fit your
34	// use case.
35	GetAPIReader() client.Reader
36
37	// Start starts the cluster
38	Start(ctx context.Context) error
39}

 1// Client knows how to perform CRUD operations on Kubernetes objects.
 2type Client interface {
 3	Reader
 4	Writer
 5	StatusClient
 6
 7	// Scheme returns the scheme this client is using.
 8	Scheme() *runtime.Scheme
 9	// RESTMapper returns the rest this client is using.
10	RESTMapper() meta.RESTMapper
11}

1func (c *nodeController) patchNodeAnnotaions(ctx context.Context, curNode *v1.Node, nodeIP string) error {
2	newNode := curNode.DeepCopy()
3	newNode.Spec = curNode.Spec
4	if newNode.Annotations == nil {
5		newNode.Annotations = make(map[string]string)
6	}
7	newNode.Annotations[nodeIPAnnotation] = nodeIP
8	return c.client.Patch(ctx, newNode, client.StrategicMergeFrom(curNode))
9}

 1// Controller implements a Kubernetes API.  A Controller manages a work queue fed reconcile.Requests
 2// from source.Sources.  Work is performed through the reconcile.Reconciler for each enqueued item.
 3// Work typically is reads and writes Kubernetes objects to make the system state match the state specified
 4// in the object Spec.
 5type Controller interface {
 6	// Reconciler is called to reconcile an object by Namespace/Name
 7	reconcile.Reconciler
 8
 9	// Watch takes events provided by a Source and uses the EventHandler to
10	// enqueue reconcile.Requests in response to the events.
11	//
12	// Watch may be provided one or more Predicates to filter events before
13	// they are given to the EventHandler.  Events will be passed to the
14	// EventHandler if all provided Predicates evaluate to true.
15	Watch(src source.Source, eventhandler handler.EventHandler, predicates ...predicate.Predicate) error
16
17	// Start starts the controller.  Start blocks until the context is closed or a
18	// controller has an error starting.
19	Start(ctx context.Context) error
20
21	// GetLogger returns this controller logger prefilled with basic information.
22	GetLogger() logr.Logger
23}

 1
 2// Result contains the result of a Reconciler invocation.
 3type Result struct {
 4	// Requeue tells the Controller to requeue the reconcile key.  Defaults to false.
 5	Requeue bool
 6
 7	// RequeueAfter if greater than 0, tells the Controller to requeue the reconcile key after the Duration.
 8	// Implies that Requeue is true, there is no need to set Requeue to true at the same time as RequeueAfter.
 9	RequeueAfter time.Duration
10}
11
12type Reconciler interface {
13	// Reconcile performs a full reconciliation for the object referred to by the Request.
14	// The Controller will requeue the Request to be processed again if an error is non-nil or
15	// Result.Requeue is true, otherwise upon completion it will remove the work from the queue.
16	Reconcile(context.Context, Request) (Result, error)
17}