Multi times reconciliations when to watch kubernetes builtin resource.

[nobody4t]

Not sure what kind this issue should be. So I just put it out. Some body may help with it.

Backgroud:
I need to inspect namesapce and do some work according to the changes, like namespace deletion or creation. This is easy with client-go. But I need it to be part of operator, say a controller.
What did I do?
I just create a controller to watch namespace resource.
what did I got ?
I got multiple times of reconciliation of the same events.
Eg. When I create a namespace, this event will be received two times. And the deletion will be 3 times.
The nice result I expect:
Just like other custom resource. I got exact one time reconciliation.
My thoughts:
I not so deep understand the mechanism of the controller-runtime API and operator-sdk.
But from my intuition, I thought this might be problematic when to watch a kubernetes builtin resource.
Because it already got a controller, which might be the cause of this. But not sure.

Is it normal to inspect a kubernetes builtin resource? I think it is good. We already can inspect other resource, like pod, deployment etc. Is it because namespace is a cluster-scoped resource?
Please help.

[camilamacedo86]

Hi @dongwangdw,

As described before, see that the reconcile will be re-trigged when ANY event such as; edit, update, delete and create occurs on the resource watched.

Beware that you can grab the events from the resources API directly to try understanding and check its better by using kubectl get events which displays recent events for all resources in the system.

For example, when you delete a namespace it is updated by the k8s API more than once since many actions until it is finally be deleted will be performed such as; update the states, remove all associated resources and dealing with finalizers, etc. And then, what I am trying to explain here is that the reconcile can be called more than once since to perform some specific request done to the K8S API many actions may be performed which means that more than one event can be raised for one specific resource.

Also, note the reconcile is like a loop, and it will just be finished when all conditions are done successfully. So, in order to achieve that, it may be performed many times and can be re-trigged by your code implementation as well. Beware of:

Another, important point to highlight is that you are probably watching other recurses as well, for example, the primary resource (the CRs of CRD), which in this case may be raising events too. For example:

// Watch for changes to primary resource Memcached
err = c.Watch(&source.Kind{Type: &cachev1alpha1.Memcached{}}, &handler.EnqueueRequestForObject{})
if err != nil {
    return err
}

Conclusion

The behaviour faced by you is over the implementation performed and how the k8s API works and the actions made by both.

Suggestion

Also, I'd like to recommend you to follow up the Getting Started and see the blog Getting started with Golang Operators by using Operator SDK if you not did it yet, because it has examples there which make easier the understanding. I hope that it helps you get better about how you can attend your needs as well.

So, shows that your question is pretty covered with the answers provided so far and then, I am closing this one. However, please feel free to raise new issues with other needs and/or questions as ask for we re-open this one if you see that it still required.

[joelanford]

@dongwangdw If there are certain changes to namespaces you don't care about, you can use a predicate when you setup your watch.