一篇带你kubebuilder实战:CRUD

在前两天的文章当中我们搭建好了本地的 K8s 开发环境，并且了解了 kubebuilder 的基本使用方法，今天就从我之前遇到的一个真实需求出发完整的写一个 Operator

需求分析

背景

在 K8s 运行的过程当中我们发现总是存在一些业务由于安全，可用性等各种各样的原因需要跑在一些独立的节点池上，这些节点池里面可能再划分一些小的节点池。

虽然我们可以使用 Taint，Label对节点进行划分，使用 nodeSelector 和 tolerations让 Pod 跑在指定的节点上，但是这样主要会有两个问题：

  • 一个是管理上不方便，在实际的使用过程中我们会发现存在错配漏配的情况 虽然在 v1.16 之后也可以使用 RuntimeClass来简化 pod 的配置，但是 RuntimClass 并不和节点进行关联[^1]
  • 另一个就是拓展需求不好实现，例如我们想要的某个节点属于网段或者当节点加入这个节点池自动开墙等

需求

1.对应用来说我们可以在创建或者更新应用时便捷的选择的对应的节点池，默认情况下不需要进行选择

2.对于节点池来说

  • 一个节点池可能有多个节点，并且一个节点也可能同时属于多个节点池
  • 不同节点池的标签、污点信息可能不同
  • 后续可以支持不同节点池的机型、安全组或者防火墙策略不同等
  • MVP 版本支持标签、污点即可

方案设计

节点池资源如下

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

节点和节点池之间的映射如何建立?

  • 我们可以利用 node-role.kubernetes.io/xxx=""标签和节点池建立映射
  • xxx 和节点池的name相对应
  • 使用这个标签的好处是，使用 kubectl get no可以很方便的看到节点属于哪个节点池
 
 
 
 
    
  
  
  
  
  1. NAME                 STATUS                     ROLES                  AGE    VERSION 
    2. 
  
  
  
  
  2. kind-control-plane   Ready,SchedulingDisabled   control-plane,master   2d2h   v1.20.2 
    3.

Pod 和节点池之间的映射如何建立?

  • 我们可以复用 RuntimeClass对象，当创建一个 NodePool 对象的时候我们就创建一个对应的 RuntimeClass 对象，然后在 Pod 中只需要加上 runtimeClassName: myclass 就可以了

注: 对于 MVP 版本来说其实我们不需要使用自定义资源，只需要通过标签和 RuntimeClass 结合就能满足需求，但是这里为了展示一个完整的流程，我们使用了自定义资源

开发

创建项目

 
 
 
 
    
  
  
  
  
  1. # 初始化项目 
    2. 
  
  
  
  
  2. kubebuilder init --repo github.com/mohuishou/blog-code/k8s-operator/03-node-pool-operator --domain lailin.xyz --skip-go-version-check 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. # 创建 api 
    5. 
  
  
  
  
  5. kubebuilder create api --group nodes --version v1 --kind NodePool 
    6.

定义对象

 
 
 
 
    
  
  
  
  
  1. // NodePoolSpec 节点池 
    2. 
  
  
  
  
  2. type NodePoolSpec struct { 
    3. 
  
  
  
  
  3.  // Taints 污点 
    4. 
  
  
  
  
  4.  Taints []v1.Taint `json:"taints,omitempty"` 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.  // Labels 标签 
    7. 
  
  
  
  
  7.  Labels map[string]string `json:"labels,omitempty"` 
    8. 
  
  
  
  
  8. } 
    9.

创建

我们实现 Reconcile 函数，req会返回当前变更的对象的 Namespace和Name信息，有这两个信息，我们就可以获取到这个对象了，所以我们的操作就是

1.获取 NodePool 对象

2.通过 NodePool 对象生成对应的 Label 查找是否已经存在对应的 Label 的 Node

  • 如果存在，就给对应的 Node 加上对应的 Taint 和 Label
  • 如果不存在就跳过

3.通过 NodePool 生成对应的 RuntimeClass ，查找是否已经存在对应的 RuntimeClass

  • 如果不存在就新建
  • 存在就跳过
 
 
 
 
    
  
  
  
  
  1. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { 
    2. 
  
  
  
  
  2.  _ = r.Log.WithValues("nodepool", req.NamespacedName) 
    3. 
  
  
  
  
  3.  // 获取对象 
    4. 
  
  
  
  
  4.  pool := &nodesv1.NodePool{} 
    5. 
  
  
  
  
  5.  if err := r.Get(ctx, req.NamespacedName, pool); err != nil { 
    6. 
  
  
  
  
  6.   return ctrl.Result{}, err 
    7. 
  
  
  
  
  7.  } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  var nodes corev1.NodeList 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.  // 查看是否存在对应的节点，如果存在那么就给这些节点加上数据 
    12. 
  
  
  
  
  12.  err := r.List(ctx, &nodes, &client.ListOptions{LabelSelector: pool.NodeLabelSelector()}) 
    13. 
  
  
  
  
  13.  if client.IgnoreNotFound(err) != nil { 
    14. 
  
  
  
  
  14.   return ctrl.Result{}, err 
    15. 
  
  
  
  
  15.  } 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  if len(nodes.Items) > 0 { 
    18. 
  
  
  
  
  18.   r.Log.Info("find nodes, will merge data", "nodes", len(nodes.Items)) 
    19. 
  
  
  
  
  19.   for _, n := range nodes.Items { 
    20. 
  
  
  
  
  20.    n := n 
    21. 
  
  
  
  
  21.    err := r.Patch(ctx, pool.Spec.ApplyNode(n), client.Merge) 
    22. 
  
  
  
  
  22.    if err != nil { 
    23. 
  
  
  
  
  23.     return ctrl.Result{}, err 
    24. 
  
  
  
  
  24.    } 
    25. 
  
  
  
  
  25.   } 
    26. 
  
  
  
  
  26.  } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.  var runtimeClass v1beta1.RuntimeClass 
    29. 
  
  
  
  
  29.  err = r.Get(ctx, client.ObjectKeyFromObject(pool.RuntimeClass()), &runtimeClass) 
    30. 
  
  
  
  
  30.  if client.IgnoreNotFound(err) != nil { 
    31. 
  
  
  
  
  31.   return ctrl.Result{}, err 
    32. 
  
  
  
  
  32.  } 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34.  // 如果不存在创建一个新的 
    35. 
  
  
  
  
  35.  if runtimeClass.Name == "" { 
    36. 
  
  
  
  
  36.   err = r.Create(ctx, pool.RuntimeClass()) 
    37. 
  
  
  
  
  37.   if err != nil { 
    38. 
  
  
  
  
  38.    return ctrl.Result{}, err 
    39. 
  
  
  
  
  39.   } 
    40. 
  
  
  
  
  40.  } 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.  return ctrl.Result{}, nil 
    43. 
  
  
  
  
  43. } 
    44.

更新

相信聪明的你已经发现上面的创建逻辑存在很多的问题

1.如果 NodePool 对象更新，Node 是否更新对应的 Taint 和Label

  • 如果 NodePool 删除了一个 Label 或Taint对应 Node 的Label或Taint 是否需要删除，怎么删除?

2.如果 NodePool 对象更新，RuntimeClass是否更新，如何更新

我们 MVP 版本实现可以简单一些，我们约定，所有属于 NodePool 的节点 Tanit 和Label信息都应该由 NodePool管理，key 包含 kubernetes 标签污点除外

 
 
 
 
    
  
  
  
  
  1. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { 
    2. 
  
  
  
  
  2.   // .... 
    3. 
  
  
  
  
  3.    
    4. 
  
  
  
  
  4.  if len(nodes.Items) > 0 { 
    5. 
  
  
  
  
  5.   r.Log.Info("find nodes, will merge data", "nodes", len(nodes.Items)) 
    6. 
  
  
  
  
  6.   for _, n := range nodes.Items { 
    7. 
  
  
  
  
  7.    n := n 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.    // 更新节点的标签和污点信息 
    10. 
  
  
  
  
  10. +   err := r.Update(ctx, pool.Spec.ApplyNode(n)) 
    11. 
  
  
  
  
  11. -   err := r.Patch(ctx, pool.Spec.ApplyNode(n), client.Merge) 
    12. 
  
  
  
  
  12.    if err != nil { 
    13. 
  
  
  
  
  13.     return ctrl.Result{}, err 
    14. 
  
  
  
  
  14.    } 
    15. 
  
  
  
  
  15.   } 
    16. 
  
  
  
  
  16.  } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  //... 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.  // 如果存在则更新 
    21. 
  
  
  
  
  21. + err = r.Client.Patch(ctx, pool.RuntimeClass(), client.Merge) 
    22. 
  
  
  
  
  22. + if err != nil { 
    23. 
  
  
  
  
  23. +  return ctrl.Result{}, err 
    24. 
  
  
  
  
  24. + } 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.  return ctrl.Result{}, err 
    27. 
  
  
  
  
  27. } 
    28.

ApplyNode 方法如下所示，主要是修改节点的标签和污点信息

 
 
 
 
    
  
  
  
  
  1. // ApplyNode 生成 Node 结构，可以用于 Patch 数据 
    2. 
  
  
  
  
  2. func (s *NodePoolSpec) ApplyNode(node corev1.Node) *corev1.Node { 
    3. 
  
  
  
  
  3.  // 除了节点池的标签之外，我们只保留 k8s 的相关标签 
    4. 
  
  
  
  
  4.  // 注意：这里的逻辑如果一个节点只能属于一个节点池 
    5. 
  
  
  
  
  5.  nodeLabels := map[string]string{} 
    6. 
  
  
  
  
  6.  for k, v := range node.Labels { 
    7. 
  
  
  
  
  7.   if strings.Contains(k, "kubernetes") { 
    8. 
  
  
  
  
  8.    nodeLabels[k] = v 
    9. 
  
  
  
  
  9.   } 
    10. 
  
  
  
  
  10.  } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.  for k, v := range s.Labels { 
    13. 
  
  
  
  
  13.   nodeLabels[k] = v 
    14. 
  
  
  
  
  14.  } 
    15. 
  
  
  
  
  15.  node.Labels = nodeLabels 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  // 污点同理 
    18. 
  
  
  
  
  18.  var taints []corev1.Taint 
    19. 
  
  
  
  
  19.  for _, taint := range node.Spec.Taints { 
    20. 
  
  
  
  
  20.   if strings.Contains(taint.Key, "kubernetes") { 
    21. 
  
  
  
  
  21.    taints = append(taints, taint) 
    22. 
  
  
  
  
  22.   } 
    23. 
  
  
  
  
  23.  } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.  node.Spec.Taints = append(taints, s.Taints...) 
    26. 
  
  
  
  
  26.  return &node 
    27. 
  
  
  
  
  27. }  
    28.

我们使用 make run将服务跑起来测试一下

首先我们准备一份 NodePool 的 CRD，使用 kubectl apply -f config/samples/ 部署一下

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

部署之后可以获取到节点的标签

 
 
 
 
    
  
  
  
  
  1. labels: 
    2. 
  
  
  
  
  2.     beta.kubernetes.io/arch: amd64 
    3. 
  
  
  
  
  3.     beta.kubernetes.io/os: linux 
    4. 
  
  
  
  
  4.     kubernetes.io/arch: amd64 
    5. 
  
  
  
  
  5.     kubernetes.io/hostname: kind-control-plane 
    6. 
  
  
  
  
  6.     kubernetes.io/os: linux 
    7. 
  
  
  
  
  7.     node-pool.lailin.xyz/master: "8" 
    8. 
  
  
  
  
  8.     node-pool.lailin.xyz/test: "2" 
    9. 
  
  
  
  
  9.     node-role.kubernetes.io/control-plane: "" 
    10. 
  
  
  
  
  10.     node-role.kubernetes.io/master: "" 
    11.

以及 RuntimeClass

 
 
 
 
    
  
  
  
  
  1. apiVersion: node.k8s.io/v1 
    2. 
  
  
  
  
  2.   handler: runc 
    3. 
  
  
  
  
  3.   kind: RuntimeClass 
    4. 
  
  
  
  
  4.   scheduling: 
    5. 
  
  
  
  
  5.     nodeSelector: 
    6. 
  
  
  
  
  6.       node-pool.lailin.xyz/master: "8" 
    7. 
  
  
  
  
  7.       node-pool.lailin.xyz/test: "2" 
    8. 
  
  
  
  
  8.     tolerations: 
    9. 
  
  
  
  
  9.     - effect: NoSchedule 
    10. 
  
  
  
  
  10.       key: node-pool.lailin.xyz 
    11. 
  
  
  
  
  11.       operator: Equal 
    12. 
  
  
  
  
  12.       value: master 
    13.

我们更新一下 NodePool

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

可以看到 RuntimeClass

 
 
 
 
    
  
  
  
  
  1. scheduling: 
    2. 
  
  
  
  
  2.   nodeSelector: 
    3. 
  
  
  
  
  3.     node-pool.lailin.xyz/master: "10" 
    4. 
  
  
  
  
  4.   tolerations: 
    5. 
  
  
  
  
  5.   - effect: NoSchedule 
    6. 
  
  
  
  
  6.     key: node-pool.lailin.xyz 
    7. 
  
  
  
  
  7.     operator: Equal 
    8. 
  
  
  
  
  8.     value: master 
    9.

和节点对应的标签信息都有了相应的变化

 
 
 
 
    
  
  
  
  
  1. labels: 
    2. 
  
  
  
  
  2.    beta.kubernetes.io/arch: amd64 
    3. 
  
  
  
  
  3.    beta.kubernetes.io/os: linux 
    4. 
  
  
  
  
  4.    kubernetes.io/arch: amd64 
    5. 
  
  
  
  
  5.    kubernetes.io/hostname: kind-control-plane 
    6. 
  
  
  
  
  6.    kubernetes.io/os: linux 
    7. 
  
  
  
  
  7.    node-pool.lailin.xyz/master: "10" 
    8. 
  
  
  
  
  8.    node-role.kubernetes.io/control-plane: "" 
    9. 
  
  
  
  
  9.    node-role.kubernetes.io/master: "" 
    10.

预删除: Finalizers

我们可以直接使用 kubectl delete NodePool name删除对应的对象，但是这样可以发现一个问题，就是 NodePool 创建的 RuntimeClass 以及其维护的 Node Taint Labels 等信息都没有被清理。

当我们想要再删除一个对象的时候，清理一写想要清理的信息时，我们就可以使用 Finalizers 特性，执行预删除的操作。

k8s 的资源对象当中存在一个 Finalizers字段，这个字段是一个字符串列表，当执行删除资源对象操作的时候，k8s 会先更新 DeletionTimestamp 时间戳，然后会去检查 Finalizers是否为空，如果为空才会执行删除逻辑。所以我们就可以利用这个特性执行一些预删除的操作。注意：预删除必须是幂等的

 
 
 
 
    
  
  
  
  
  1. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { 
    2. 
  
  
  
  
  2.  _ = r.Log.WithValues("nodepool", req.NamespacedName) 
    3. 
  
  
  
  
  3.  // ...... 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. + // 进入预删除流程 
    6. 
  
  
  
  
  6. + if !pool.DeletionTimestamp.IsZero() { 
    7. 
  
  
  
  
  7. +  return ctrl.Result{}, r.nodeFinalizer(ctx, pool, nodes.Items) 
    8. 
  
  
  
  
  8. + } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. + // 如果删除时间戳为空说明现在不需要删除该数据，我们将 nodeFinalizer 加入到资源中 
    11. 
  
  
  
  
  11. + if !containsString(pool.Finalizers, nodeFinalizer) { 
    12. 
  
  
  
  
  12. +  pool.Finalizers = append(pool.Finalizers, nodeFinalizer) 
    13. 
  
  
  
  
  13. +  if err := r.Client.Update(ctx, pool); err != nil { 
    14. 
  
  
  
  
  14. +   return ctrl.Result{}, err 
    15. 
  
  
  
  
  15. +  } 
    16. 
  
  
  
  
  16. + } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  // ...... 
    19. 
  
  
  
  
  19. } 
    20.

预删除的逻辑如下

 
 
 
 
    
  
  
  
  
  1. // 节点预删除逻辑 
    2. 
  
  
  
  
  2. func (r *NodePoolReconciler) nodeFinalizer(ctx context.Context, pool *nodesv1.NodePool, nodes []corev1.Node) error { 
    3. 
  
  
  
  
  3.  // 不为空就说明进入到预删除流程 
    4. 
  
  
  
  
  4.  for _, n := range nodes { 
    5. 
  
  
  
  
  5.   n := n 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.   // 更新节点的标签和污点信息 
    8. 
  
  
  
  
  8.   err := r.Update(ctx, pool.Spec.CleanNode(n)) 
    9. 
  
  
  
  
  9.   if err != nil { 
    10. 
  
  
  
  
  10.    return err 
    11. 
  
  
  
  
  11.   } 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.  // 预删除执行完毕，移除 nodeFinalizer 
    15. 
  
  
  
  
  15.  pool.Finalizers = removeString(pool.Finalizers, nodeFinalizer) 
    16. 
  
  
  
  
  16.  return r.Client.Update(ctx, pool) 
    17. 
  
  
  
  
  17. } 
    18.

我们执行 kubectl delete NodePool master 然后再获取节点信息可以发现，除了 kubernetes 的标签其他 NodePool 附加的标签都已经被删除掉了

 
 
 
 
    
  
  
  
  
  1. labels: 
    2. 
  
  
  
  
  2.      beta.kubernetes.io/arch: amd64 
    3. 
  
  
  
  
  3.      beta.kubernetes.io/os: linux 
    4. 
  
  
  
  
  4.      kubernetes.io/arch: amd64 
    5. 
  
  
  
  
  5.      kubernetes.io/hostname: kind-control-plane 
    6. 
  
  
  
  
  6.      kubernetes.io/os: linux 
    7. 
  
  
  
  
  7.      node-role.kubernetes.io/control-plane: "" 
    8. 
  
  
  
  
  8.      node-role.kubernetes.io/master: "" 
    9.

OwnerReference

我们上面使用 Finalizer 的时候只处理了 Node 的相关数据，没有处理 RuntimeClass，能不能用相同的方式进行处理呢?当然是可以的，但是不够优雅。

对于这种一一映射或者是附带创建出来的资源，更好的方式是在子资源的 OwnerReference 上加上对应的 id，这样我们删除对应的 NodePool 的时候所有 OwnerReference 是这个对象的对象都会被删除掉，就不用我们自己对这些逻辑进行处理了。

 
 
 
 
    
  
  
  
  
  1. func (r *NodePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { 
    2. 
  
  
  
  
  2.  //... 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  // 如果不存在创建一个新的 
    5. 
  
  
  
  
  5.  if runtimeClass.Name == "" { 
    6. 
  
  
  
  
  6. +  runtimeClass = pool.RuntimeClass() 
    7. 
  
  
  
  
  7. +  err = ctrl.SetControllerReference(pool, runtimeClass, r.Scheme) 
    8. 
  
  
  
  
  8. +  if err != nil { 
    9. 
  
  
  
  
  9. +   return ctrl.Result{}, err 
    10. 
  
  
  
  
  10. +  } 
    11. 
  
  
  
  
  11. +  err = r.Create(ctx, runtimeClass) 
    12. 
  
  
  
  
  12. -  err = r.Create(ctx, pool.RuntimeClass()) 
    13. 
  
  
  
  
  13.   return ctrl.Result{}, err 
    14. 
  
  
  
  
  14.  } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.  // ... 
    17. 
  
  
  
  
  17. } 
    18.

在创建的时候使用 controllerutil.SetOwnerReference 设置一下 OwnerReference 即可，然后我们再试试删除就可以发现 RuntimeClass 也一并被删除了。

注意，RuntimeClass 是一个集群级别的资源，我们最开始创建的 NodePool 是 Namespace 级别的，直接运行会报错，因为 Cluster 级别的 OwnerReference 不允许是 Namespace 的资源。

这个需要在 api/v1/nodepool_types.go 添加一行注释，指定为 Cluster 级别

 
 
 
 
    
  
  
  
  
  1. //+kubebuilder:object:root=true 
    2. 
  
  
  
  
  2. +//+kubebuilder:resource:scope=Cluster 
    3. 
  
  
  
  
  3. //+kubebuilder:subresource:status 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. // NodePool is the Schema for the nodepools API 
    6. 
  
  
  
  
  6. type NodePool struct { 
    7.

修改之后我们需要先执行 make uninstall 然后再执行 make install

总结

回顾一下，这篇文章我们实现了一个 NodePool 的 Operator 用来控制节点以及对应的 RuntimeClass，除了基本的 CURD 之外我们还学习了预删除和 OwnerReference 的使用方式。之前在 kubectl delete 某个资源的时候有时候会卡住，这个其实是因为在执行预删除的操作，可能本来也比较慢，也有可能是预删除的时候返回了错误导致的。

下一篇我们一起来为我们的 Operator 加上 Event 和 Status。

参考文献

[^1]: 容器运行时类(Runtime Class):

https://kubernetes.io/zh/docs/concepts/containers/runtime-class/

[^2]: kubebuilder 进阶使用:

https://zhuanlan.zhihu.com/p/144978395

[^3]: kubebuilder2.0学习笔记——搭建和使用

https://segmentfault.com/a/1190000020338350

[^4]: KiND - How I Wasted a Day Loading Local Docker Images:

https://iximiuz.com/en/posts/kubernetes-kind-load-docker-image/

标题名称：一篇带你kubebuilder实战:CRUD
浏览路径：http://www.csdahua.cn/qtweb/news8/327808.html

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

广告

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

成都快上网为您推荐相关内容

品牌网站制作知识

分类信息网

网站排名优化　　 　重庆手机网站建设　　 　定制网站制作　　 　班戈纳美网站　　 　成都路面机械设备　　 　企业网站建设公司　　 　成都网站SEO优化公司　　 　四川内江电信机房　　 　子晨木包装箱　　 　公司网站建设　　 　网站优化排名推广　　 　添翼二手车鉴定　　 　鸿艺文化　　 　成都主机托管　　 　重庆小程序开发公司　　 　成都主机租用　　 　工程造价　　 　香港服务器空间　　 　成都包装设计公司　　 　名片印刷厂