一篇带你kubebuilder实战:status&event

在上篇文章当中我们实现了 NodePool Operator 基本的 CURD 功能，跑了一小段时间之后除了 CURD 之外我们有了更高的需求，想知道一个节点池有多少的节点，现在的资源占比是多少，这样可以清晰的知道我们现在的水位线是多少，除此之外也想知道节点池数量发生变化的相关事件信息，什么时候节点池增加或者是减少了一个节点等。

需求

我们先整理一下需求

能够通过 kubectl get Nodepool了解当前的节点池的以下信息

  • 节点池的状态，是否异常
  • 节点池现在包含多少个节点
  • 节点池的资源情况现在有多少 CPU、Memory

能够通过事件信息得知 controller 的错误情况以及节点池内节点的变化情况

实现

Status

先修改一下 status 对象，注意要确保下面的 //+kubebuilder:subresource:status注释存在，这个表示开启 status 子资源，status 对象修改好之后需要重新执行一遍 make install

 
 
 
 
    
  
  
  
  
  1. // NodePoolStatus defines the observed state of NodePool
    2. 
  
  
  
  
  2. type NodePoolStatus struct {
    3. 
  
  
  
  
  3.  // status=200 说明正常，其他情况为异常情况
    4. 
  
  
  
  
  4.  Status int `json:"status"`
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.  // 节点的数量
    7. 
  
  
  
  
  7.  NodeCount int `json:"nodeCount"`
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.  // 允许被调度的容量
    10. 
  
  
  
  
  10.  Allocatable corev1.ResourceList `json:"allocatable,omitempty" protobuf:"bytes,2,rep,name=allocatable,casttype=ResourceList,castkey=ResourceName"`
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. //+kubebuilder:object:root=true
    14. 
  
  
  
  
  14. //+kubebuilder:resource:scope=Cluster
    15. 
  
  
  
  
  15. //+kubebuilder:subresource:status
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. // NodePool is the Schema for the nodepools API
    18. 
  
  
  
  
  18. type NodePool struct {
    19.

然后修改 Reconcile 中的逻辑

 
 
 
 
    
  
  
  
  
  1. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    2. 
  
  
  
  
  2.  // ......
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.  if len(nodes.Items) > 0 {
    5. 
  
  
  
  
  5.   r.Log.Info("find nodes, will merge data", "nodes", len(nodes.Items))
    6. 
  
  
  
  
  6. +  pool.Status.Allocatable = corev1.ResourceList{}
    7. 
  
  
  
  
  7. +  pool.Status.NodeCount = len(nodes.Items)
    8. 
  
  
  
  
  8.   for _, n := range nodes.Items {
    9. 
  
  
  
  
  9.    n := n
    10. 
  
  
  
  
  10. 
  
  
  
  
  11.    // 更新节点的标签和污点信息
    12. 
  
  
  
  
  12.    err := r.Update(ctx, pool.Spec.ApplyNode(n))
    13. 
  
  
  
  
  13.    if err != nil {
    14. 
  
  
  
  
  14.     return ctrl.Result{}, err
    15. 
  
  
  
  
  15.    }
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. +   for name, quantity := range n.Status.Allocatable {
    18. 
  
  
  
  
  18. +    q, ok := pool.Status.Allocatable[name]
    19. 
  
  
  
  
  19. +    if ok {
    20. 
  
  
  
  
  20. +     q.Add(quantity)
    21. 
  
  
  
  
  21. +     pool.Status.Allocatable[name] = q
    22. 
  
  
  
  
  22. +     continue
    23. 
  
  
  
  
  23. +    }
    24. 
  
  
  
  
  24. +    pool.Status.Allocatable[name] = quantity
    25. 
  
  
  
  
  25. +   }
    26. 
  
  
  
  
  26.   }
    27. 
  
  
  
  
  27.  }
    28. 
  
  
  
  
  28. 
  
  
  
  
  29.   // ......
    30. 
  
  
  
  
  30.   
    31. 
  
  
  
  
  31. + pool.Status.Status = 200
    32. 
  
  
  
  
  32. + err = r.Status().Update(ctx, pool)
    33. 
  
  
  
  
  33.  return ctrl.Result{}, err
    34. 
  
  
  
  
  34. }
    35.

修改好了之后我们提交一个 NodePool 测试一下

 
 
 
 
    
  
  
  
  
  1. apiVersion: nodes.lailin.xyz/v1
    2. 
  
  
  
  
  2. kind: NodePool
    3. 
  
  
  
  
  3. metadata:
    4. 
  
  
  
  
  4.   name: worker
    5. 
  
  
  
  
  5. spec:
    6. 
  
  
  
  
  6.   taints:
    7. 
  
  
  
  
  7.     - key: node-pool.lailin.xyz
    8. 
  
  
  
  
  8.       value: worker
    9. 
  
  
  
  
  9.       effect: NoSchedule
    10. 
  
  
  
  
  10.   labels:
    11. 
  
  
  
  
  11.     "node-pool.lailin.xyz/worker": "10"
    12. 
  
  
  
  
  12.   handler: runc
    13.

可以看到我们现在是有两个 worker 节点

 
 
 
 
    
  
  
  
  
  1. ▶ kubectl get no 
    2. 
  
  
  
  
  2. NAME                 STATUS   ROLES                  AGE   VERSION
    3. 
  
  
  
  
  3. kind-control-plane   Ready    control-plane,master   29m   v1.20.2
    4. 
  
  
  
  
  4. kind-worker          Ready    worker                 28m   v1.20.2
    5. 
  
  
  
  
  5. kind-worker2         Ready    worker                 28m   v1.20.2
    6.

 然后我们看看 NodePool，可以发现已经存在了预期的 status

 
 
 
 
    
  
  
  
  
  1. status:
    2. 
  
  
  
  
  2.   allocatable:
    3. 
  
  
  
  
  3.     cpu: "8"
    4. 
  
  
  
  
  4.     ephemeral-storage: 184026512Ki
    5. 
  
  
  
  
  5.     hugepages-1Gi: "0"
    6. 
  
  
  
  
  6.     hugepages-2Mi: "0"
    7. 
  
  
  
  
  7.     memory: 6129040Ki
    8. 
  
  
  
  
  8.     pods: "220"
    9. 
  
  
  
  
  9.   nodeCount: 2
    10. 
  
  
  
  
  10.   status: 200
    11.

现在这样只能通过查看 yaml 详情才能看到，当 NodePool 稍微多一些的时候就不太方便，我们现在给NodePool 增加一些 kubectl 展示的列

 
 
 
 
    
  
  
  
  
  1. +//+kubebuilder:printcolumn:JSONPath=".status.status",name=Status,type=integer
    2. 
  
  
  
  
  2. +//+kubebuilder:printcolumn:JSONPath=".status.nodeCount",name=NodeCount,type=integer
    3. 
  
  
  
  
  3. //+kubebuilder:object:root=true
    4. 
  
  
  
  
  4. //+kubebuilder:resource:scope=Cluster
    5. 
  
  
  
  
  5. //+kubebuilder:subresource:status
    6.

如上所示只需要添加好对应的注释，然后执行 make install即可

然后再执行 kubectl get NodePool 就可以看到对应的列了

 
 
 
 
    
  
  
  
  
  1. ▶ kubectl get NodePool 
    2. 
  
  
  
  
  2. NAME     STATUS   NODECOUNT
    3. 
  
  
  
  
  3. worker   200      2
    4.

Event

我们在 controller 当中添加 Recorder 用来记录事件，K8s 中事件有 Normal 和 Warning 两种类型

 
 
 
 
    
  
  
  
  
  1. // NodePoolReconciler reconciles a NodePool object
    2. 
  
  
  
  
  2. type NodePoolReconciler struct {
    3. 
  
  
  
  
  3.  client.Client
    4. 
  
  
  
  
  4.  Log      logr.Logger
    5. 
  
  
  
  
  5.  Scheme   *runtime.Scheme
    6. 
  
  
  
  
  6. + Recorder record.EventRecorder
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. + // 添加测试事件
    12. 
  
  
  
  
  12. + r.Recorder.Event(pool, corev1.EventTypeNormal, "test", "test")
    13. 
  
  
  
  
  13. 
  
  
  
  
  14.  pool.Status.Status = 200
    15. 
  
  
  
  
  15.  err = r.Status().Update(ctx, pool)
    16. 
  
  
  
  
  16.  return ctrl.Result{}, err
    17. 
  
  
  
  
  17. }
    18.

添加好之后还需要在 main.go 中加上 Recorder的初始化逻辑

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

加好之后我们运行一下，然后在 describe Nodepool 对象就能看到事件信息了

 
 
 
 
    
  
  
  
  
  1. Events:
    2. 
  
  
  
  
  2.   Type    Reason  Age   From      Message
    3. 
  
  
  
  
  3.   ----    ------  ----  ----      -------
    4. 
  
  
  
  
  4.   Normal  test    4s    NodePool  test
    5.

监听更多资源

之前我们所有的代码都是围绕着 NodePool 的变化来展开的，但是我们如果修改了 Node 的相关标签，将 Node 添加到一个 NodePool，Node 上对应的属性和 NodePool 的 status 信息也不会改变。如果我们想要实现上面的效果就需要监听更多的资源变化。

在 controller 当中我们可以看到一个 SetupWithManager方法，这个方法说明了我们需要监听哪些资源的变化

 
 
 
 
    
  
  
  
  
  1. // SetupWithManager sets up the controller with the Manager.
    2. 
  
  
  
  
  2. func (r *NodePoolReconciler) SetupWithManager(mgr ctrl.Manager) error {
    3. 
  
  
  
  
  3.  return ctrl.NewControllerManagedBy(mgr).
    4. 
  
  
  
  
  4.   For(&nodesv1.NodePool{}).
    5. 
  
  
  
  
  5.   Complete(r)
    6. 
  
  
  
  
  6. }
    7.

其中 NewControllerManagedBy是一个建造者模式，返回的是一个 builder 对象，其包含了用于构建的 For、Owns、Watches、WithEventFilter等方法

这里我们就可以利用 ``Watches方法来监听 Node 的变化，我们这里使用handler.Funcs`自定义了一个入队器

监听 Node 对象的更新事件，如果存在和 NodePool 关联的 node 对象更新就把对应的 NodePool 入队

 
 
 
 
    
  
  
  
  
  1. // SetupWithManager sets up the controller with the Manager.
    2. 
  
  
  
  
  2. func (r *NodePoolReconciler) SetupWithManager(mgr ctrl.Manager) error {
    3. 
  
  
  
  
  3.  return ctrl.NewControllerManagedBy(mgr).
    4. 
  
  
  
  
  4.   For(&nodesv1.NodePool{}).
    5. 
  
  
  
  
  5.   Watches(&source.Kind{Type: &corev1.Node{}}, handler.Funcs{UpdateFunc: r.nodeUpdateHandler}).
    6. 
  
  
  
  
  6.   Complete(r)
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. func (r *NodePoolReconciler) nodeUpdateHandler(e event.UpdateEvent, q workqueue.RateLimitingInterface) {
    10. 
  
  
  
  
  10.  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    11. 
  
  
  
  
  11.  defer cancel()
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.  oldPool, err := r.getNodePoolByLabels(ctx, e.ObjectOld.GetLabels())
    14. 
  
  
  
  
  14.  if err != nil {
    15. 
  
  
  
  
  15.   r.Log.Error(err, "get node pool err")
    16. 
  
  
  
  
  16.  }
    17. 
  
  
  
  
  17.  if oldPool != nil {
    18. 
  
  
  
  
  18.   q.Add(reconcile.Request{
    19. 
  
  
  
  
  19.    NamespacedName: types.NamespacedName{Name: oldPool.Name},
    20. 
  
  
  
  
  20.   })
    21. 
  
  
  
  
  21.  }
    22. 
  
  
  
  
  22. 
  
  
  
  
  23.  newPool, err := r.getNodePoolByLabels(ctx, e.ObjectOld.GetLabels())
    24. 
  
  
  
  
  24.  if err != nil {
    25. 
  
  
  
  
  25.   r.Log.Error(err, "get node pool err")
    26. 
  
  
  
  
  26.  }
    27. 
  
  
  
  
  27.  if newPool != nil {
    28. 
  
  
  
  
  28.   q.Add(reconcile.Request{
    29. 
  
  
  
  
  29.    NamespacedName: types.NamespacedName{Name: newPool.Name},
    30. 
  
  
  
  
  30.   })
    31. 
  
  
  
  
  31.  }
    32. 
  
  
  
  
  32. }
    33. 
  
  
  
  
  33. 
  
  
  
  
  34. func (r *NodePoolReconciler) getNodePoolByLabels(ctx context.Context, labels map[string]string) (*nodesv1.NodePool, error) {
    35. 
  
  
  
  
  35.  pool := &nodesv1.NodePool{}
    36. 
  
  
  
  
  36.  for k := range labels {
    37. 
  
  
  
  
  37.   ss := strings.Split(k, "node-role.kubernetes.io/")
    38. 
  
  
  
  
  38.   if len(ss) != 2 {
    39. 
  
  
  
  
  39.    continue
    40. 
  
  
  
  
  40.   }
    41. 
  
  
  
  
  41.   err := r.Client.Get(ctx, types.NamespacedName{Name: ss[1]}, pool)
    42. 
  
  
  
  
  42.   if err == nil {
    43. 
  
  
  
  
  43.    return pool, nil
    44. 
  
  
  
  
  44.   }
    45. 
  
  
  
  
  45. 
  
  
  
  
  46.   if client.IgnoreNotFound(err) != nil {
    47. 
  
  
  
  
  47.    return nil, err
    48. 
  
  
  
  
  48.   }
    49. 
  
  
  
  
  49.  }
    50. 
  
  
  
  
  50.  return nil, nil
    51. 
  
  
  
  
  51. }
    52.

总结

今天我们完善了 status & event 和自定义对象 watch 下一篇我们看一下如何对我们的 Operator 进行测试

本文名称：一篇带你kubebuilder实战:status&event
URL分享：http://www.hantingmc.com/qtweb/news28/330228.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

自适应网站知识

分类信息网

网站推广营销　　 　乐至网站建设　　 　成都广告制作　　 　虚拟主机　　 　LED亮化工程　　 　成都谷歌SEO　　 　成都电信服务器托管　　 　营销型网站建设　　 　江油网站建设　　 　济桢教育　　 　康明斯发电机　　 　定制网站开发　　 　名片印刷厂　　 　成都微信开发　　 　微官网开发　　 　达州做网站　　 　定制级高端网站建设　　 　交互设计　　 　响应式网站建设公司　　 　时嘉做网站