如何在K8s Controller Runtime中让Reconciler重试x次后停止重排队？

在controller-runtime框架下，要实现重试x次后终止调和流程，核心思路是追踪重试次数并在达到阈值时主动停止重排，以下是几种落地性强的方案：

方案1：通过CRD状态字段记录重试次数（最常用） #

在自定义资源（CR）的Status字段中新增RetryCount和Phase（如Failed/Running）字段，每次调和失败时递增计数，达到阈值后停止重排并标记状态。

代码示例： #

1. 先在CRD的Status结构体中定义字段：

type MyCRStatus struct {
    // 其他状态字段
    RetryCount int    `json:"retryCount,omitempty"`
    Phase      string `json:"phase,omitempty"`
}

2. 在Reconcile逻辑中处理重试计数：

func (r *MyCRReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    cr := &myv1.MyCR{}
    if err := r.Get(ctx, req.NamespacedName, cr); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // 检查是否已达到重试阈值
    const maxRetries = 3
    if cr.Status.RetryCount >= maxRetries {
        // 标记资源状态为失败，不再重试
        cr.Status.Phase = "Failed"
        if err := r.Status().Update(ctx, cr); err != nil {
            return ctrl.Result{}, err
        }
        // 发送事件通知运维
        r.Recorder.Event(cr, corev1.EventTypeWarning, "MaxRetriesReached", "已达到最大重试次数，终止调和")
        return ctrl.Result{Requeue: false}, nil
    }

    // 执行核心调和逻辑
    if err := r.doReconcileLogic(cr); err != nil {
        // 重试次数递增
        cr.Status.RetryCount++
        if updateErr := r.Status().Update(ctx, cr); updateErr != nil {
            return ctrl.Result{}, updateErr
        }
        // 可以设置退避延迟，也直接返回error触发重试
        return ctrl.Result{RequeueAfter: time.Minute}, err
    }

    // 调和成功，重置重试计数
    cr.Status.RetryCount = 0
    cr.Status.Phase = "Succeeded"
    if err := r.Status().Update(ctx, cr); err != nil {
        return ctrl.Result{}, err
    }
    return ctrl.Result{Requeue: false}, nil
}

方案2：自定义RateLimiter控制重试行为 #

通过自定义ratelimiter.RateLimiter接口，为每个资源对象追踪重试次数，达到阈值后返回无限大的延迟（等同于停止重排）。

代码示例： #

1. 实现自定义RateLimiter：

type MaxRetryRateLimiter struct {
    delegate    ratelimiter.RateLimiter
    maxRetries  int
    retryCounts map[string]int // key: 资源的namespacedName
    mu          sync.Mutex
}

func NewMaxRetryRateLimiter(delegate ratelimiter.RateLimiter, maxRetries int) *MaxRetryRateLimiter {
    return &MaxRetryRateLimiter{
        delegate:    delegate,
        maxRetries:  maxRetries,
        retryCounts: make(map[string]int),
    }
}

func (rl *MaxRetryRateLimiter) When(item ratelimiter.Key) time.Duration {
    rl.mu.Lock()
    defer rl.mu.Unlock()
    key := string(item)
    if rl.retryCounts[key] >= rl.maxRetries {
        // 返回无限大延迟，不再重排
        return time.Duration(math.MaxInt64)
    }
    rl.retryCounts[key]++
    return rl.delegate.When(item)
}

func (rl *MaxRetryRateLimiter) Forget(item ratelimiter.Key) {
    rl.mu.Lock()
    defer rl.mu.Unlock()
    delete(rl.retryCounts, string(item))
}

2. 创建控制器时绑定自定义RateLimiter：

func SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&myv1.MyCR{}).
        // 使用自定义RateLimiter，基于默认的BucketRateLimiter包装
        WithRateLimiter(NewMaxRetryRateLimiter(ratelimiter.NewBucketRateLimiter(1, 5), 3)).
        Complete(&MyCRReconciler{
            Client:   mgr.GetClient(),
            Recorder: mgr.GetEventRecorderFor("mycr-controller"),
        })
}

方案3：结合Finalizer实现优雅终止（可选） #

如果需要在终止前清理资源，可以给CR添加Finalizer，当达到重试阈值时，执行清理逻辑后移除Finalizer，确保资源最终处于稳定状态。

关键逻辑： #

// 在达到重试阈值时
cr.Status.Phase = "Failed"
// 添加清理逻辑
if err := r.cleanupResources(cr); err != nil {
    return ctrl.Result{}, err
}
// 移除Finalizer
cr.Finalizers = slices.DeleteFunc(cr.Finalizers, func(f string) bool {
    return f == "mycr.cleanup.example.com"
})
if err := r.Update(ctx, cr); err != nil {
    return ctrl.Result{}, err
}
return ctrl.Result{Requeue: false}, nil

内容的提问来源于stack exchange，提问作者Aishwarya Nagaraj