shell-operator VS metacontroller

Maybe, the Shell operator is a good tool for that?

Shell-operator to parse logs and make action after the pod crash.

Argo workflow can trigger from k8s objects but may be a bit more than you need, shell-operator may be good enough https://github.com/flant/shell-operator for a quick win

I used https://github.com/flant/shell-operator to write a simple Kubernetes operator that automatically creates subdomains for your services by patching an existing ingress.

If you are more into lightweight and common use cases, look at metacontroller or the shell-operator.

Believe it or not, you can write a Kubernetes operator using simple shell scripts: https://github.com/flant/shell-operator

You could use something like shell operator, metacontroller, or operator-sdk to run a command against your load balancer's API whenever a LoadBalancer service is created.

https://github.com/flant/shell-operator should get you quite far but this sounds like the process should just shut itself down when that case is hit...

shell-operator is already used in KubeSphere's ks-installer, Confluent's Kafka DevOps solution, Deckhouse Kubernetes platform, and more. All documentation is available in the project's GitHub repo — if you feel it might be interesting for your needs, give it a try! Any feedback is warmly welcome.

It worth adopt proper controller development with something like Metacontroller, Kopf or Java Operator SDK.

There are many frameworks, like the Operator Framework (https://operatorframework.io/) to the MetaController (https://github.com/metacontroller/metacontroller) to KubeBuilder(https://github.com/kubernetes-sigs/kubebuilder) to the Kubernetes Operator Framework (kopf, https://kopf.readthedocs.io/en/stable/), among others.

You might like a little alternative to writing your own in the first instance:) take a look at https://metacontroller.github.io/metacontroller/

Codegen is not magic, but if you want to make it simple stupid, supportable and prod-usable I'd go for metacontroller. There's not much magic to it - just common admission/validation webhooks propagated to your controller implementation, alongside the simplest possible reconciliation cycle. We had adopted Knative driven metacontrollers and it's a pretty solid approach.

https://github.com/metacontroller/metacontroller - Sounds cool! I will look into it.

When I need a quick mutating controller, I like to use MetaController, which makes rapid prototyping really easy: https://metacontroller.github.io/metacontroller/

If you are more into lightweight and common use cases, look at metacontroller or the shell-operator.

In case you've not heard of it, the metacontroller aims to do exactly this. It provides the controller-lifecycle (registering your types, watching the API for changes, etc), you just need to provide a HTTP webhook to receive the JSON object, and respond with the modifications\resources you want.