Handle ending of a pod

[lperdereau]

Hello,

I'm starting with your library.
I'm searching a way to handle the completion of my pod previously created.

The flow should give this :

• Create a CRD
• Handle CRD creation (kopf.on.create)
• Create a Pod for a tasks (template + python kuberntes)
• Pod complete its tasks
• Handle pod termination
• Start a new tasks

I'm searching a way like async/await on some event to handle modification of ressource status but I didn't find it easly.

Could you help me please 🙏

P.S.: Very good job I really like your library

[nolar]

Hello. Thank you.

Kopf does not support linear scenarios — mostly because Kubernetes itself is highly non-linear and event-driven. For linear workflows, I would recommend looking at specialised workflow engines like Argo, maybe something else.

For this described task, you have to react to pods' changes and patch the relevant parent resource. For patching, you will have to know its name (and namespace — for cross-namespace patching). I would recommend putting that name into the labels when you create pods — basically, the same as built-in Jobs do with their Pods.

Optionally, if you need to aggregate the status of several children (pods) to make a decision on the next step, you also need another handler on the parent resource itself, where it takes the info from all(!) children at once, analyses it, and does something with that. A single pod's event cannot be aware of the whole parent's state to make such decisions ("yet"; #661 might change that) — so you have to move the info forth & back between resources.

import kopf

@kopf.on.create('kopfexample')
def created(namespace, name, **_):
    pod = {'kind': 'Pod', ...}
    kopf.label(pod, {'my-parent': name})
    kopf.adopt(pod)
    really_create_pod(namespace, pod)

@kopf.on.update('pods', labels={'my-parent': kopf.PRESENT}, field='status.phase', new='Succeeded')
def pod_changed(namespace, name, labels, **_):
    parent_name = labels['my-parent']
    really_patch_kopfexample(namespace, parent_name, {'status': {'my-children': {name: {'done': True}}}})

@kopf.on.update('kopfexample', field='status.my-children')
def newinfo(old, new, diff, **_):
    print(diff)
    print(new)  # {'pod1': {'done': True}, 'pod2': {'done': True}, ...}
    ...  # do something

This is an idea to start with. I didn't test if this code works, but the concept itself works — we use a similar approach in our operators.

This solution depends on status.phase field of the pod (docs). It is not the most reliable source of information on the pod's status. There are also pod conditions in status.conditions — this is a better way, though more wordy. You might need Kopf's when= filter instead of simple field-/value-filters for that.

Also note: with this approach, you can create not only Pods directly, but also indirectly — e.g. via Jobs. Just ensure that the Pod gets its label in .spec.template.metadata.labels too, not only the root Job (Kopf supports that as "nested" fields to adopt(), label(), etc).

I hope this helps.

[lperdereau]

I just noticed that I never answer to you since 19 Feb, but yes thank you.
I proceed like you said and it's petty cool too.

Do you know where can I find project skeleton with Kopf ? I'm searching a good way to sort my files/handlers.
Is there a code convention for operator ?

[thismatters]

I've been working on something that might be relevant to what you're trying. Part of my process involves starting a pod and waiting until it is complete before doing any other part of the pipeline.

I've probably mangled things a little bit, but I've managed to implement a pipeline which proceeds through several steps, waiting when necessary for a resource to complete or become available.

I started to look into Argo, but its marketing site made me nauseous and its "quick start" didn't seem so quick. Looking at it makes me relatively certain that I'm going to be shown an invoice for it sometime in the near future.