Kubernetes Operator Finalizers 使用

func (r *CronJobReconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
    ctx := context.Background()
    log := r.Log.WithValues("cronjob", req.NamespacedName)

    var cronJob batch.CronJob
    if err := r.Get(ctx, req.NamespacedName, &cronJob); err != nil {
        log.Error(err, "unable to fetch CronJob")
        return ctrl.Result{}, ignoreNotFound(err)
    }

    // 声明 finalizer 字段，类型为字符串
    myFinalizerName := "storage.finalizers.tutorial.kubebuilder.io"

    // 通过检查 DeletionTimestamp 字段是否为0 判断资源是否被删除
    if cronJob.ObjectMeta.DeletionTimestamp.IsZero() {
        // 如果为0 ，则资源未被删除，我们需要检测是否存在 finalizer，如果不存在，则添加，并更新到资源对象中
        if !containsString(cronJob.ObjectMeta.Finalizers, myFinalizerName) {
            cronJob.ObjectMeta.Finalizers = append(cronJob.ObjectMeta.Finalizers, myFinalizerName)
            if err := r.Update(context.Background(), cronJob); err != nil {
                return ctrl.Result{}, err
            }
        }
    } else {
        // 如果不为 0 ，则对象处于删除中
        if containsString(cronJob.ObjectMeta.Finalizers, myFinalizerName) {
            // 如果存在 finalizer 且与上述声明的 finalizer 匹配，那么执行对应 hook 逻辑
            if err := r.deleteExternalResources(cronJob); err != nil {
                // 如果删除失败，则直接返回对应 err，controller 会自动执行重试逻辑
                return ctrl.Result{}, err
            }

            // 如果对应 hook 执行成功，那么清空 finalizers， k8s 删除对应资源
            cronJob.ObjectMeta.Finalizers = removeString(cronJob.ObjectMeta.Finalizers, myFinalizerName)
            if err := r.Update(context.Background(), cronJob); err != nil {
                return ctrl.Result{}, err
            }
        }

        return ctrl.Result{}, err
    }
}

func (r *Reconciler) deleteExternalResources(cronJob *batch.CronJob) error {
    //
    // 删除 crobJob关联的外部资源逻辑
    //
    // 需要确保实现是幂等的
}

func containsString(slice []string, s string) bool {
    for _, item := range slice {
        if item == s {
            return true
        }
    }
    return false
}

func removeString(slice []string, s string) (result []string) {
    for _, item := range slice {
        if item == s {
            continue
        }
        result = append(result, item)
    }
    return
}

// Reconcile ensures the back-end state reflects the Kubernetes resource state intent.
func (r *VSphereMachineReconciler) Reconcile(req ctrl.Request) (_ ctrl.Result, reterr error) {
 ...
 // Always close the context when exiting this function so we can persist any VSphereMachine changes.
 defer func() {
  if err := machineContext.Patch(); err != nil && reterr == nil {
   reterr = err
  }
 }()

 // Handle deleted machines
 if !vsphereMachine.ObjectMeta.DeletionTimestamp.IsZero() {
  return r.reconcileDelete(machineContext)
 }

 // Handle non-deleted machines
 return r.reconcileNormal(machineContext)
}

func (r *VSphereMachineReconciler) reconcileDelete(ctx *context.MachineContext) (reconcile.Result, error) {
 ctx.Logger.Info("Handling deleted VSphereMachine")

 var vmService services.VirtualMachineService = &govmomi.VMService{}

    // 执行删除虚拟机逻辑
 vm, err := vmService.DestroyVM(ctx)
 if err != nil {
        // 如果删除失败，则直接返回错误，controller 会自动重试
  return reconcile.Result{}, errors.Wrapf(err, "failed to destroy VM")
 }

 // 重新调度删除虚拟机逻辑，直到虚拟机状态处于 notfound 状态
 if vm.State != infrav1.VirtualMachineStateNotFound {
  ctx.Logger.V(6).Info("requeuing operation until vm state is reconciled", "expected-vm-state", infrav1.VirtualMachineStateNotFound, "actual-vm-state", vm.State)
  return reconcile.Result{RequeueAfter: config.DefaultRequeue}, nil
 }

 // pre-delete hook执行成功，也就是上面的删除虚拟机逻辑执行成功，则清空 Finalizers
 ctx.VSphereMachine.Finalizers = clusterutilv1.Filter(ctx.VSphereMachine.Finalizers, infrav1.MachineFinalizer)

 return reconcile.Result{}, nil
}

}else{
 customdeployment:=obj.(*crdv1alpha1.CustomDeployment).DeepCopy()
 fmt.Println("Event..............................")
 if customdeployment.DeletionTimestamp != nil{
  // check if it has finalizer
  if customdeployment.GetFinalizers()!=nil{
   finalizers:=customdeployment.GetFinalizers()

   // check if first finalizer match with deletepod.crd.emruz.com
   if finalizers[0]=="deletepods.crd.emruz.com"{
    //
    _,err:=myutil.PatchCustomDeployment(c.clientset,customdeployment, func(deployment *crdv1alpha1.CustomDeployment) *crdv1alpha1.CustomDeployment {
     // delete pods under this deployment
     err:=myutil.DeletePods(c.kubeclient,c.podLabel)
     if err!=nil{
      fmt.Println("Failed to remove all pods. Reason: ",err)
      return nil
     }
     // pods sucessfully removed. remove the finalizer
     customdeployment.ObjectMeta=myutil.RemoveFinalizer(customdeployment.ObjectMeta)
     return customdeployment
    })
    if err!=nil{
     return err
    }
   }
           }