Cloud Native Computing Foundation App Delivery Special Interest Group, 8 Apr 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: CNCF SIG App Delivery 2020-04-08

Description

CNCF SIG App Delivery 2020-04-08

A

B

Not a lot of people here, yet, let's I guess give it a couple of minutes.

B

A

C

B

B

Think Jared was gonna. Try to join also so Allah doesn't appear to be online, it's slack right now, so I guess we can.

C

Yeah, maybe if, if these meetings usually did you read the first book meeting, is a lot of people show up? It might be beneficial to set it out to the mailing list again, because sometimes people get confused for themselves. Just is it I.

B

Think that's a great idea, um so that's a be the agenda here.

B

Okay, so there's not like a lot on the on the planned agenda right now, so everybody has access to the doc here, we'll go ahead and get started, meetings being recorded, we'll send out a link to it afterwards.

B

Well, like I mentioned, there's like there's no announcements, there's no like planned like items on the topic so like, let's start off with you, know kind of like putting the agenda together for the meeting today. Does anybody have anything that they they want to discuss? They want to add to the agenda. I'll go ahead and just add on to the darker talk here: the.

C

Only that we could add is the existing document about the operator definition that I could throw in. Maybe because I was the first goal.

B

You're gonna drop a link into the docker yeah.

C

I just have to open it: okay dropped it right into you.

C

Just give me a second sure.

C

We can share and discuss what is already there if you want to just ad one more second, and here we go, should be perfect.

B

Cool I can actually share my screen. We can have the stock up just in case anybody doesn't have access to it right now,.

B

B

So I'm sharing it I have the doc up on the screen. Everybody can see it. Okay, awesome, so I think you know like the goal here is to continue to up to define, like you know what what it, what an operator is, I think that's like the first.

B

You know do too much else like what's included in an operator, what's not included in an operator. This is like a doc. That's been going around for a while, so I think everybody's, hopefully our chance to read it um and, like you know, I, don't know if, like it's definitely not something we're gonna like be able to like solve today on this call, but like I, think we should like continue to push forward on like the discussion and see what you know. If anybody has any more any further thoughts on it,.

D

Well, hey folks, yeah, my friend here I actually have a lot of thoughts on this doc, some of them I've put in it. I was looking at it again this morning, but what I've noticed here- and maybe it's me- the question was originally asked. What is an operator right? That was what was asked from the TOC to SigEp delivery, but I noticed that the doc gets a lot into things that go beyond that, such as a capability model and the capability model came out of the operator framework. It hasn't really been worked out.

D

The other operator projects, and it also isn't something that was actually asked of well anybody from the TOC and so I think, maybe looking at what they actually asked like what is inaudible all the nuances they just kind of define what it is and then explain that I think that's what they asked for and Dastak kind of diverges from. So that's my big.

C

On different levels, and part of that definition was also what capabilities an operator should provide beyond the few technical ones, and that's why it's made it in there and I.

C

Don't think we have to live by the word of everything that we have been asked to do, but also provide what is needed by the community, and when we discuss this, we have certain discussions, especially around like what separates an operator from a controller and that's why we would in there that this doesn't mean, however, that out of this designation, we need to have a capability model in there. We just put it in there when it comes to capabilities, because beyond you operate the model there was discussions should only be stateful or non States.

C

So that's the reason why it's in there so nobody's that'll be defining in a so.

D

So let me ask this in', so if this document captures a whole bunch of thing, is this the document that we are planning to pass up, that kind of explains here's? What an operator is, here's the outcome, or is this a place? That's just capturing a bunch of information and talking through it.

C

D

Because we're you know the working document that captures lots of things is different than kind of the output that answers the questions and that's useful for people who walk away because the general person is not going to be as involve this conversation sa you or me, and they just want the outcome in a short, concise manner, but a working document that captures lots of things and links out to it maybe has long form explanations that that entirely makes sense to capture all of these things.

D

But I would suggest that a capability model may be something that should be gotten into, but I would separate it from the definition. So that way, the definition can get out there quickly and these kinds of things that probably should be discussed with lots of different operator projects, kudo operator framework and the other ways of doing things will take a lot longer to get through and it may change drastically by the time that it comes out. Who knows what will come out from those long form? Discussions.

B

My my understanding- and my might hope, is that this document is that working document that we kind of, like think of it, that's the all-encompassing things that may make it into that final, like definition of an operator, and then we can distill it down into that smaller like this, is actually what the definition of an operator is and if the capability model is or is not in it I think that's a decision we make but like like.

B

We should definitely include it as like a candidate to make it into a into the into the definition overtime like I I, don't I, don't have an opinion about whether or not it is part of that but, like, like you, know, right now, I think it's like, like data collection mode, what could potentially make it into the definition of an operator before we can actually figure out like what what the pic is like this is actually what the operator is defined as.

E

Yeah, like maybe we just break elegant sources or prayer, it's alright! Sorry, everyone I had the wrong calendars turned on, like maybe we have like a prior art or like research section here just to make it clear like like this is just stuff that we are taking leap frog right just going in because I I'm of the mind like. Maybe this is not part of the like, like we have a super gold like the old, a maturity model or like thinking about maturity, models or or just consider those things.

E

Then everything is part of this, but you know there's definitional stuff. That's in this capability model that we may want to refer to when building out our actual definition, I.

C

Just linked the actual definition, by the way that it's currently in the equipment is this definition and this documentation just put it in the agenda. So we have to smell there as well.

B

Yeah and I think like I, think we're the reason that we're here is like this current definition. That's in the coopered are these documentation is somewhat vague and lacking, and so we're trying to like.

C

Because it's like deploying an application of the man taking and restoring backups of the application handling upgrades publishing a service application that service applications that don't support communities api's to discover them, simulating failure all parts of your cluster to test its resilience. So there it's actually part yeah exactly this bits and pieces. So we have it's called the indica needs documentation as examples well.

D

It doesn't actually say this: is the capability model, it's giving examples of what it might look like to do that, and it gives examples here, but it doesn't actually say what it is, which means, logically, that this could be. It doesn't mean that it's everything, that's inclusive or that it involves some kind of structure for a capability model. I think it's just trying to paint the picture of what this might be, not list what it is. It's trying to paint a picture rather than fill in all of the details and yeah.

B

Yeah I mean I think that kind of comes back to the same conversation that it's you know like it is an operator like. Is it a CR D or or is it not a Sierra T? Does it doesn't require that an operator includes a custom resource definition and the controller that runs in the cluster? Doesn't the definition of an operator it's it's kind of in that same, like encompassing area of like the definition of an operator right now. Well,.

D

If we look at the the original definition that came out of chorus when they they defined it, just like a find this, so the original definition that was from Brandon, Phillips and and Karass said an operator is an application-specific controller that extends the kubernetes api to create, configure and manage instances of complex stateful applications on behalf of a kubernetes user. It builds upon the basic kubernetes resource and controller concept, but it includes domain or application specific knowledge to automate common tasks.

D

Now that right, there kind of has a I would argue three specific things that make something an operator. First, it extends the kubernetes api and if you look at extending the api, there's actually two ways to do this. You can use custom api server, which is what the Service Catalog project did and that's from before we had CRTs or anything that created that right.

D

You can do that, although it's really really hard the much easier and more common path to do, that is with CRTs and custom controllers, and that kind of thing, and so I would argue if it extends the API and probably either one of those ways. Most likely through CRT, because it's easier then that's the first check right. Does it extend the API and if you have a controller that never extends the API at all.

D

You probably miss that checkbox I mean it's right in the definition of it has to extend the API, and this builds upon the other parts, because really what you're getting into is the declarative model and in the declarative model. You declare what you want and then the system works to make that possible. But if you don't ever have a API to declare what you want, then your operator doesn't know what you want in order to make that possible, and so, if you don't have that extension, you're, probably not an operator.

D

The second thing that it gets into is domain or application specific knowledge, and it goes on to say that it has to define common tasks right and- and so you need to look at. Does it have it? So if something like meta controllers, my example of something that's a controller, but it's not an operator because it doesn't have application specific knowledge, it's a controller that actually helps you build. Other controllers, but something like one of the Postgres operators that has application specific knowledge for Postgres.

D

Well, that has application domain-specific knowledge in order to accomplish something: you're not going to be able to use that operator to run I, don't know WordPress or something entirely different, because it's only targeted at that and then what are good. The third thing is: is it needs to manage instances of applications on behalf of the kubernetes user? So you, you know if I'm using coop, CTL and I want to deploy my sequel right. I have to know my sequel.

D

I've got to know the ins and outs I've got to run, commands I've got a crown the files and do that kind of thing. I actually have to know. Kubernetes and I have to know my sequel and I've got to know the business logic and marry it, and if I want something to happen or change within my cluster, like backups things like that, I actually have to go, create the cron job or what else I'm gonna do right.

D

You have to deal with the business logic side of that, but an operator it says, I'm gonna, capture, information about that application and then I'm gonna manage that application for you, based on what you've done for me. Do you say you need to have so many replicas and h.a? Do you want backups? Okay, give me your schedule for backups. However, we want to do it. We're just gonna make it happen, and we manage that for you, so you don't have to think about it right.

D

Those are kind of the three big things that were in that definition and if you use that definition and you basically rip out the stateful set side of it or the stateful part of it right and you just take that out, you've got those three criteria right there and you can actually write that out in the long form and then you can test anything against those right. The Postgres operator and meta control are easy.

D

Things to test fluxes was brought up the other day and the call is kind of that hard one to test and and I basically I've written up. What that would look like, but this is one of those things like it's they're plain as day as long as we just expand on that definition and then we're not breaking from it. We're not trying to green fill their own definition and and the details are there. So at least that's my two cents on this and you don't have to get into the the capability model.

D

That's a later thing. We could do it. We can respond to the TOC in short order. Both were the short form definition and an explanation, and we can move on to the other things, because that's what they ultimately asked for all right, I'll shut up now, cuz I've been rambling for a while.

B

It's it's good I agree, I mean that's that that definitely is the current definition of an operator. Flux is definitely an example of something that's kind of you know. You know in a weird place like it doesn't extend. You know the kubernetes API directly I, don't deploy like you know, like the flux helm operator, get, is a different, different beast, but and I think that it also like comes down to, like you know, managing an application from an operational perspective. Shouldn't be like a one time like install like like it's using an operator to deploy.

B

Postgres is different than using an operator to manage the lights, to manage Postgres running in the cluster and make sure that it like it continues to work right like like monitoring like making changes to parameters that are necessary, and things like this, like operators for install versus operators for runtime yeah Matt I, was.

D

Just gonna ask in our defining operators to respond to the TOC and to share to people. Do we have to get into the nuances of what the common tasks are? Is that a requirement of providing an explanation? I, don't.

B

Know if, like a requirement, actually I, don't think that our requirement is to define the common tasks, but there like to like income to like define what areas of the lifecycle of an application that an operator like is potentially or should be responsible for is. It is something that just installs an application and then done, and it never touches it again. Is that does that meet the definition of an operator or not? That's a question.

D

If something that just installs an application, so if we go back to, let's go back to the definition, because I think this is wonderful, the definition says it says includes domain or application specific knowledge to automate common tasks right, and so the question is: is by something that just installs an application. It never touches it again. Is it actually automating common tasks? We can sit around and argue whether it is or isn't.

D

I would actually argue that it's not because you're not getting into the common tasks, but do we need to answer that question in some form of long form description in order to respond to the TOC on this.

B

Do we have to jared given 8ne you wanna jump in on any any company, I.

E

Think right now we do with how we we we've not written it down. So why we're not being specific enough right and in the exact terms we mean, but because I, because I I do I do agree like is it? Is it enough, for example, to do for definitional like like? Let's just, let's apply the test right to that? That definition is.

E

I'm gonna just I'm first gonna pick on Picon helm, but he's tiller an operator and and because in actually that's a bad one, that's wrong! No.

D

Tillers, not an operator, and it's not a custom controller anyway. So it's an easy way.

E

D

Always bad because it's not a controller yeah and it's also not application-specific. It's not targeted at something like Postgres. To continue my example. It is a more general thing, and so it fails that test as well. Yes,.

E

Okay, so cert manager, so they're not calling themselves an operator right now under this definition is, would we consider certain manager, an operator.

E

It doesn't manage an application, so it manages certificates, but it does extend the API. It is a controller.

D

Do we have to answer that before we have a definition they.

F

D

Themselves, that, and not all things that are extensions to the kubernetes api are in fact operators.

E

But are we should be able to apply a litmus test or own definition before we even internally?

E

We don't answer it to the TOC, but we should ask ourselves that, like like does art is, is the wording we're using our definition specific enough before we pass the definition so that we don't have to be long for it because I know I, don't want to go long form like if we don't have to, but if we're missing specificity and in what we're saying and too many things in our in our own, like gut check before we pass it, that's gonna cause questions and stuff something right. Let's.

D

A system, let's I said, um does the: does it extend the kubernetes api? Well, the answer to that is yes right. Does it contain application, specific knowledge and.

G

So the question.

D

Is so what is the actual application here? Is it their own custom application, which is something that it also manages? So it's.

F

Ready this one, hey guys, I, have a good question, so anyone here so I'm kind of wrapping my hair around. So we my question here because I see Botha argument at the old body, but the question here it seems to me is: do we actually have to use the word application? Because that's the only thing that I see support that is creating the confusion, because some money, it does have a domain-specific soft word. That needs to have some knowledge in order to be operated, but it's not I, wouldn't call it application like, for example, poetry.

F

That's the only word that is creating confusion, at least for me. Maybe you guys can okay.

D

So so the original chorus definition said: domain or application, specific knowledge and and I for one don't want to remove the or application here, because I think for a general audience, that's going to make that example more clear in their minds, because they're gonna start to ask what's an application, in my case, for what I'm doing and if you say, domain or application specific it kind of zooms in and answers it for most people, but it doesn't preclude the domain part of it, and so the chorus folks really I think cleared that up for us when they originally wrote it, and so no that's great here, does the the cert manager do domain or application specific stuff?

D

F

D

And then our and this one is, what may be the hard one comes into our the the applications or or the thing managed right? Is it managed by the operator instead of the kubernetes user? Yes right, and so so I like framing it as a question that can hopefully be answered? Yes, no and it can kind of be boiled down to those three questions, and maybe we've got to finagle the language a little bit of it.

D

But if we can answer yes, no to those and all three are yes, then it's an operator by their definition right how it does it into what level it does. It are things we can debate in essence, but it can be boiled down to three yes-or-no questions. I think.

C

Don't want to look at components and want to decide necessarily whether they're no operator or not very often, the question that I hear from people is okay. I have built XYZ on top of kubernetes, whatever it is, should and it's kind of complex to manage, because if it's just a very simple piece of workloads, usually people might not care, should I build an operator to manage and run this thing or should not, and will it help me so coming from an end user perspective rather than looking at something? Oh, this looks like an operator.

C

Does this really matter? It's all the one thing I'm looking at it, but at the end of the day, one problem we need to solve as a community is making running workloads on kubernetes less complex than it is today, and so a lot.

G

C

Have not really done a necessarily great job at that, like even at some point. We just made it more and more complex that count, for example, how much arts did not really make it easier to run stuff, except that you have to apply one helm to the building. It doesn't make anything easier and it doesn't cover certain things. So that's my point here who do we want to help.

D

So so III think there's actually two separate things here. The first is helping people who have that question and I think that's entirely valid to try to come up with answers for them, but then there's answering the question that was asked to say: gap delivery by the TOC. What is an operator because what it is and should I get into one and then the third thing I would argue from what you just said is how can I build a toolkit? That's useful for people to help them move faster and make it simpler.

D

Are three separate questions for three different target audiences that each need their own response, and so the first one here was just trying to the TOC back before the holiday break. Asked this question and now we're something like five months later and they're.

C

Waiting for a response of what an operator is what actually need. Yes, there was the question ken was agreed.

C

And make it and I know where this question was asked: how about Italy part of this conversation?

C

They came up as part of the operator hub discussion, if you remember mm-hmm, but like installing applications, so I think that these three questions actually go well together, because if you have a constructor like an operator, the first question is: why does it exist?.

C

What do you know what it exists and we can't define okay, what how should it be? What should constitute this construct like see these controls whatever and how do I create? One is then, the next one.

C

What it is today might be one this.

D

Guy I guess what I'm arguing for here is the TOC asked for something, and we should probably give them the answer to the thing that they asked for and then take the other two things that were brought up and look at who the target audience is and then craft something specific for them.

D

Because of definition of an operator isn't something that people are creating frameworks probably need to have right and should I use an operator, it's kind of a separate thing and should I use an operator, it's kind of for end-users who either want to create one or maybe look at using an existing one. And then somebody who produces an operator is in an entirely different role and and what they need to think about is different than the end-users right. And so there's different target audiences and I.

C

Like to think either this or like this agree here honestly, but but I have never built any product in my life that it did not first thing of what I'm going to use it for and then this is.

C

This feels like we talk about technical constructs that exist on now in case kubernetes like see these are operators and, by the way, keep in mind that technically everything we do is cap native, so they should also work outside of kubernetes, while we're not focusing on right now, but I could build like so even something like the current operator like a file definition and something that has the reconciliation loop running on top of it even with lambda and C NS, we park it conceptually.

C

The key question for me is: why does this thing exist and why should people be using it and then what falls into it for me is important and then I'm thinking about the technical details. It feels a bit weird just taking the technical concept and then later on finding a use case for it.

D

And I'm actually not arguing that I'm actually arguing there's different roles in this whole thing: okay and so I'll take helm for an example. You brought up helm and so with helm, it's a package manager right at its heart. It is a package manager and I like to relate it to something like apt and so with apt right.

D

Somebody who has domain knowledge of Debian based systems and domain knowledge of an application, puts together a package and then distributes it and somebody else who doesn't need to know intimate knowledge of those debian based systems or of operating that application can install it and get it up running quickly and use it right. It's a great way to share applications and make it easy to install it.

D

So I use apt-get install all the time on my systems without actually knowing all the intricacies of where files need to go and the binaries and all this stuff and that's kind of where helm comes from. But if you break that down there's two different roles: there's me as somebody who's producing the package and the knowledge I need and the considerations I need to have and then there's somebody who's going to be installing it and the role they have where they need to discover the packages, be able to evaluate them and install them.

D

But they don't need to know the intricacies and some people are gonna. Wear both hats right. Some people wear both hats. Where I'm doing it. We used to use apt where I used to work to manage our own deployment workflows in staging production and things like that, and we needed to wear both hats. But the common case is you.

D

You still have these different roles and so to think about what you produce for those different roles and what's useful for them and not trying to put them all together, because you know then you're starting to mix things up and you've got to pick.

D

What's for me and what's not and where do I go into what level of detail but actually crafting things that help people in the different roles where they're at I think that would be useful in our case, I've listed two here: who's the the operator consumer who's just going to install it and get it up and running, then there's the person who's producing operators, those are kind of two different roles and then, of course, in this case, because there's an ass from the TOC there's answering that toc question and giving them what they asked for as just even a point of process, because I think they're still wanting that.

D

But I don't know if there's a TOC. No there's no TOC member here to answer that, but even giving them as a role as somebody who asked for something in us giving them what they asked for, and so those are kind of the three things that I at least was thinking of. How do you give each of those their thing? So.

G

So I'm going to chime in here last point or at least to start on that last point- is that we can to the letter, give the TLC what they asked for, or we can give them what they need and what they may need more than a strict technical definition is they may need. They might really have been asking the question. Okay, help us really define why operators are valuable.

G

So when I think about this them, I've been listening very very carefully here, trying to form some opinions and they're still not quite formed, but you know to me: operators are a way of having somebody be able to package up a capability and for a different constituency to be able to consume that capability at the core. That's what an operator is I like parts of the definition that you drew out from the original core I, for example, love the fact they extend the API.

G

One I think that one's pretty important so I think there's elements of that definition, but I tend to also want to back up and say why? What are the problems that we're trying to solve with the operator before we start defining what it is so so I guess I'm lending some support to you a lot so.

D

Let me ask this week: do we get to define what an operator is, or is it something that is already defined in the market, because we aren't green fielding here and and I? Think that's that's one of things. It's not like. We get to decide what an operator is. Operators have been in the market for years and maybe they need to be described and it need to be written down, but it isn't new. It isn't we're, not the creators of operators, I.

B

Think that, like that's true but I, think like the goal here is to better define what actually is an operator so that we can kind of put like like something that maybe currently called an operator actually doesn't meet the definition of an operator and therefore like as a consumer of that operator, I, don't expect the same functionality, the same services that that thing provides because it's like it's operator and Jason right now, right, like I, might look at helm until err, Humvee, 2 and say that's an operator because it's actually likes me.

B

It creates this abstraction around the kubernetes api, so I can just run helm, install and he'll them upgrade it so to manage my charts, which are applications and that's an operator. But like that's, not an operator, I think matt. You agreed to that point. You should your head pretty emphatically when Jared mentioned that hell might be an operator and like being able to say, look helm, you might think of home as an operator, but it doesn't meet Lee fit into this bucket of what we.

B

What we in this group define as an operator means like you, shouldn't, expect the operators, services and operator functionality, and you shouldn't expect as a consumer for it to fit into like other tooling that are built on the operator ecosystem.

B

So I think, like you know, defining it is definitely necessary here. We we, we don't get to define like what people are going to create, but we do get to define, like this label operator, that we could let people can kind of like slap on and say like this meets the definition of an operator. That's that's what I think.

C

Installers use it to install complex applications, but, like one key aspect of an operator for me, is also the reconciliation. Do like the dynamic piece of it. It's just not a system that simply installs something, and then the scare was what happens. It actually checks that that something happens because it's actually we're just doing a cute controller ply. Let's go back to like the very basics and I'm just applying a Yabba file. I, don't know whether this thing is even working out.

C

So it is the basic primitive of the platform, but I'm not sure what anything happens. So yeah I think the more ethereal I.

B

Think that comes back to the, including in the definition that it's like it extends the kubernetes api and it has an in cluster controller or I don't know if maybe in cluster might be too too too broad there but like it seems a common use case. But I could controller, which is continually running a reconciling to like to manage that application. Hey Jed, so.

E

So the throw a loop here- let's, let's go back to our home example- and bring up I'm gonna I'm gonna- bring Kudo into this right. Because because- and my question is, does this have to be a singular holistic unit because, for example, Kudo can then start to bring in a reconciliation, loop and and very stay to operations to a helm sure right eventually to a scene, a bundle? Everything else so is that combination of things that installation of post grass, with from a chart with a Kudo, could have life cycle around it?

E

Is that now an operator or is it not because it's not a single controller? That also knows about Postgres.

D

So so, let's get into this, um so we'll ask the question with with the chorus one and then and maybe debate it right. Does it extend the kubernetes api? Alright does it? How are my questions? What.

E

It now becomes the question: what's the it yeah.

D

In the kudo example is domain or application specific knowledge included in kudo. I.

B

Mean what is what what's the application? Is it the application that could that the operator that was written in CUDA is or is it beads that the app could it was like a meta operator right like it actually like? Is it? Has the application and the domain-specific knowledge of how to like, create and run that operator inside the cluster Jared? Is that a fair, exactly.

E

Exactly yeah, it's so so.

D

If I understand it right, what you're saying is kudo itself is not an operator, but an operator created with kudo has extends the api and contains the application or domain-specific knowledge right.

E

Yes, no, that said it in some cases, it only contains domain-specific knowledge right because it's bringing in an external home church.

D

Sure and then you've got to ask our common tasks being accomplished right and and their language was to automate common tasks. That's the language in the Kouros definition, and so would common tasks be done, and so in this case a common task might be also Postgres install upgrade delete. You might do backups. Can those common tasks to.

C

Be accomplished by.

D

C

For the common tasks- yes, because, actually back to the previous point of certificate management, when using a certificate, is a common task. Updating s secret is a common task. Updating routing rules is a common task.

D

The common tasks are going to be different per application or domain area right, I think that's one of the things we just caught because doing cert manager is going to have intense certificate management. It's gonna be an entirely different set of common tasks from something like Postgres I hadn't thought of that before.

C

That's why I think defining what a common task, at least by example, is and I think that's what the capability model did. But that's what way beyond that within, like sales managing and so forth. But we find that what is a common task, at least that we have for Anita's privileges so.

D

We could give examples of common tasks, but I don't think we can define them because to define them means we need to know all the areas and certificate, cert manager or yeah and Postgres operators are gonna. Have you know, database operator, they're gonna have different sets of common tasks and I'm sure there's so many different applications out.

D

There were so many different common tasks that it's probably not useful for us to define the common tasks, because we're not going to know everything to be able to define everything but providing examples of common tasks to illustrate them for people may be very useful. Yeah.

B

I, don't think that we're gonna be able to like provide. You know an exhaustive list of every possible common tasks that an operator could could could meet right because, like to your point like to every application, is a little bit different. There's the common set of common tasks around like application lifecycle management which, like an operator, doesn't have to necessarily like implement, but you know Kudo when I write an engine X operator using Kudo like it may be that that operator is just installing and upgrading engine X inside the cluster. Does that still meet it.

D

But it's also gonna if you break out of the application, as we talked about earlier to the domain, you may not have the simple install process right and I think cert manager brought up is a fantastic example of that. Are you really installing an instance of an application? It's more domain area than application, and so do those common tasks hold when you break out of the application model into the domain model.

C

Let's encrypt operated.

C

B

Though, to go to your to your point, to like I mean the core OS original core OS definition said domain or application, specific knowledge, not domain and application. Specific knowledge so like in in this case, like I, totally agree with you, there's a very different definition between domain and application and like this nginx cluedo example, is like it's kind of like it's, not a very full-featured operator, but it still meets the definition there.

B

D

Me ask this to actually create a definition. Do we need to define this because I know we could take a long time defining and thinking through all these things in order to create that that definition, is it useful for us to go down all of these roads or just to consider and give some examples of common tasks and move on to some of the other things like the role of as a consumer of an operator?

D

Should I use one right and move on to something that targets that role and provides them with the contextual information they need to say: ok should I bother with an operator in this particular case. How can I myself figure out if I should, as a consumer of them, and that may be, it may be useful to just switch gears into that. Instead of spending lots of time going down this hole, I think.

B

The answer to that question about whether we should have to whether we should include that definition, kind of comes back to you like should is, should the definition of operator be like this really wide umbrella. That covers like everything that like sits inside the kubernetes cluster, that manages other applications not like a not a final application, or should it be a very narrowly targeted. Like very specific thing that says like it has to extend the kubernetes api, it has to include domain or specific knowledge.

B

Like the original definition says, it has to be stateful components that doesn't feel like I think we most people agree that that could probably get removed and does it have to have a name cluster reconcile controller loop, that's running to like manage the life cycle or instead of just a one-time process of like managing these like. If we, if we start with saying like, is that the definition of an operator- that's that's, you know kind of relatively broad but like it excludes random things.

B

D

Mean if I take out stateful stuff from theirs, it seems pretty still solid to me, because if I go and start extending it further, then you have a hard time of saying: I've got a random controller and some CRTs and it doesn't do anything that's domain or application-specific. Is it now an operator yeah.

B

I actually agree, I think that's a good starting point to the definition. I think that, like the only one that I have some doubt still about personally, is like in in cluster controller reconcile. Is that a requirement to be an operator because, like, as you know, coop Control extensions are being like more and more like widely adopted and you're? Seeing those more is it possible that you could actually have something that runs as an operator? That's invoked through a food control plugin, as opposed to like running inside the cluster, so is in classed or required.

B

G

But the reconciler it needs to be in the cluster I personally think that it has to have a reconciler I and there has to be some reconciliation. So.

D

So I think this is a great topic to dig into, and so let's get to the heart of this kubernetes is a declarative model right. You declare what you want and then the controller takes that and attempts to make it so and provide status on that situation right, and so, if you move it out of cluster right, then where is the thing that looks for the changes that is reconciling and making the necessary changes to say? Oh this no longer matches now I'm gonna update in kubernetes.

D

That tends to be the controller, whether it's custom, control or whatnot. Looking at events, if you've got something outside of the cluster, it is no longer watching for events, it's no longer watching for changes on an event loop that does that, and so in many ways.

C

C

For example, or you can look at this monitoring system that have Romberg automation labels, they are not running in the caster. None of these components does he looked for town then, and our go home boy likes a bit of. We don't use any of these components, but we had a lot of operators to look at response times of an application of the love service.

C

When these response times go above a certain threshold, we automatically scale up the service or, if whatever behavior we disabled features lags. So we do a lot what an operated us we can do it directly with acute control applied. We actually reconcile whether the service is doing what we want to do going beyond chas the instances running of technical there's no component running inside the cluster and result is.

B

There, an extension of the kubernetes api, a married, also know.

C

Well, we have, we have built it with extensions to the api, but I cannot be entirely without extensions. I can just have a monitoring system, : and simple script that doesn't use control apply and it's.

B

A great question: not do you actually think that that's an operator do you want to call that an operator or not? I.

C

Don't need to coin upgrade. It uses the operator pattern. That's the interesting thing for what that's done, but it's not.

A

I shirt your first okay.

E

Actually, no I'm gonna try to throw a wrench in so you go first, okay,.

D

Well, what I was gonna say is: is this application or domain specific I was gonna question.

C

And we have domains application, specific actions like this everything and they're doing feature flags scaling things up or down, so it is application specific it actually, the only one who can be fine. It is somebody who knows their application so.

D

The the system is targeted at a specific application like Postgres and not applications in general. So I can't monitor some random application and say look at the metrics for this and scale it. It's a general thing right or is it a specific to an application or domain like certificate management? I would.

C

Always have to define this very example where I'm using it for dynamically man managing deployments based on monitoring data, it would always be applications specific. What I want to do with under certain cases me. This goes beyond just killing stuff I forget if it fits so it could say this is not applications with it. So.

D

So it's it's to the application specifically not to the type specifically like you're, not monitoring, all deployments and scaling them. It's only deployments and you can relate the type of application running as the deployment and then do that.

C

B

D

Running a controller but you're running it out of cluster rather than in cluster, is what you're saying yeah.

C

And they have to reconcile loop as I'm monitoring and looking at the data so for the link, almost all requirements at a conceptual level of nominative implementation level and I'm, not claiming it's supposed to be good enough. Greater, don't get me wrong, I'm, just saying I'm implementing all the concepts we talked about conceptually just my implementation is different. Okay,.

D

I I would like to point out one thing before I pass it off here. Real quick is operators become an amazing branding thing and so I know lots of people want to put things into operators I think it's useful to say what it is and what it isn't, but I I also don't want to hope for more things to be operators just somehow fit into the branding bucket.

D

As part of this whole thing that just occurred to me, there's this desire to say oh, my thing's, an operator to to use it as a branding and a thought and there's so many useful things that are not operators. We shouldn't try to go with that branding bandwagon, but that's me I'll shut up with my soapbox. Alright.

E

Quick quick wrench into this, because I I agree with what you're saying, but you know there's something here that has a lot more possibilities to it: potentially and there's okay. Well, when we say reconciler, right and and and can control what we really mean is a process that is watching again point that detects a you know: it's detects a level change.

E

It compares two things in advance of state right like that's all, reconciler is and- and we have a bacon assumption at the that is coming from that, whatever the end points of whatever you're watching those resources.

E

Now, let's say in getting two marks like like running it from cute cuddle point or running it from your command line. If you have all the controller logic baked into a CLI tool that did all the exact same things except the end user was the one say, kicking off and most probably there's other ways to do this, of course, but like if I'm just hitting up enter up, enter up enter on my on my computer over and over and over again running one run of the controller loop controller brain event.

E

Loop is that an operator like like it's it's doing all those things and there's there's there's you know some some things I've been thinking on and and and others here, like they've, been thinking about like where these operators like semantics, could be very useful without being like in a event-driven like where event loop right, like not being bound by that event, loop and always running.

B

Yeah I mean I, agree. I, also really quick point out like we're like at time for like what this meeting was scheduled for. So like it's, it's a it's an interesting conversation, there's a lot of a lot of opinions. It's a good conversation. Jared I, I, totally agree with that point, though, like I, don't have an answer for you. I think like that's just something that like I, do think we need to define Matt to your point like we need to define like I.

B

Don't think like we want to say like here's, this, like it's, it's a branding opportunity and what what might potentially be included in an operator there's there's there may be stuff that gets carved off and gets a different label and gets a different term that has its own working group and its own save over time and like maybe the coop cuttle plugins is not actually an operator and in cluster control. Reconcile loops are actually a requirement. I think part of our goal here should be to make that decision.

D

Yeah and I guess I'll just leave when I think about what we should do and what we can do and what were scope to do. I was actually reminded that this all falls under the TOC and I just dropped a link into the TOC scope right um and so I.

D

You will find me being a little careful in coming up with things like the TOC, isn't scoped with creating terms, but we can document what's already there and we can create white papers that are useful for people, but we don't get to create whole categories and and or I, don't really think that there's scope for that and so I'm just keeping this in mind, and so when you all wonder why I come with the opinions I come with in the direction. It's really because I'm attempting to stay in scope and on direction.

D

You'll find that a lot with me, and so at least that will express why I come at it. The way I do.

B

That's a great link to kind of kind of like limit the scope of what we're trying to do when we define it so.

E

E

Now and in two weeks, we working the stock trying to pare this down, get to a definition and Mark. What do you think communication here or in the mailing list? I.

B

Mean I think: can you define what what here is like wait for two weeks until the next next meeting or the mailing list would be like more ad hoc and like in continuous right, yeah.

E

Yeah exactly like what are we, what do we want to kick this off with in the next two weeks, yeah.

B

I mean I think we should continue to work on the on the document. I think you know, like everybody has it. It's like listed, is the first topic here like we can even edit it. We can make comments on it and the mailing list is there to like discuss stuff, but, like I, mean I'm, look I, think all of us are like pretty pretty excited and have some strong opinions about it.

B

So, like let's discuss them in that document and like if we need to we can oh, we can go to the mailing list too, but there's no reason to wait until the next two weeks meeting either.

D

So I've one question here: I wrote up another document, just I was trying to figure it out, starting with the definition and then explanation and test. It's radically different and I didn't want to like overwrite. What you already had I can send that out to the mailing list or otherwise share it, but it because it's so different in structure I didn't want to like drop it in and go crazy on your document. So I wasn't sure what to do, but I'll share it to the mailing list, and then we can take it from there.

D

This was me just trying to work through it and pick it apart with details on each thing, but I.

A

B

To mess with years.

D

Which is the reason I'm not gonna, just drop it in it's like 2 and 1/2 pages long I mean.

B

I've read through the document you sent out this morning. Intense it's good like I, mean I think also it probably worth adding a link to the to it. There's like an alternative like suggested reading for people who are reading that one doc is like you know, another approach, service, yeah.

D

And I was just trying to I wanted a logic reason based structure through my thinking on this, which is why I put it together and tests. So that was my purpose, because I hadn't really thought through it prior to writing that up. Writing sometimes gives me the ability to think.

B

C

So I, like meetings where we have something that we can prep for like we have now a lot of things that we want to have in there and we can have at least from the people who are here plus the ones with a mailing list. What do you consider important, yeah, I think.

B

C

Important to consider is here the important, if not point out, you could even put this into a Google Form and see what comes out of it exactly.

B

I think this mean this meeting came, did a lot of really good discovery and kind of opened up some questions that we can like now have like more more deeper dives into those questions, and hopefully you know in the next two. You know two weeks from now, when we get back together for a meeting will like have a very clear agenda with some questions that we should have some more everybody set a little bit of chance to kind of Croc and read and understand so yeah, okay, all right! Well, let's wrap up for now.

B

Thanks everybody for attending we'll send the the like notes out the agenda. Is there and then the zoom recording will go up Thanks.

A