Layer5 Service Mesh Patterns, 7 Jun 2021

Previous Meeting

⏯

youtube image

►

From YouTube: Contributing to Meshery UI using Service Mesh Patterns (June 7th, 2021)

Description

Contributing to Meshery UI using Service Mesh Patterns (June 7th, 2021)

Join the community at https://layer5.io/community

Find Layer5 on:
GitHub: https://github.com/layer5io
Twitter: https://twitter.com/layer5
LinkedIn: https://www.linkedin.com/company/layer5
Docker Hub: https://hub.docker.com/u/layer5/

A

Let's start from the ui, uh this is not in any terms the final version. uh I was just experimenting that how we can fit in everything in here, but the basic idea is that all of these components that you can see in him is dynamic rendered. That is, none of it is actually coded into the front end, not istio mesh. Not these input boxes, nothing, nothing of it is actually in the front they get dynamically generated, and that's what this session is would be mostly about. That is how we can.

A

We can work more towards it. How we can uh basically make the ui more interesting. As you can see, this is this is not the best thing. We have something called settings we have traits. You can want to estimate those kind of things. So the thing is that if these forms are getting generated dynamically then how they are, what um how can? uh How can we also kind of we can also tweak these things?

A

So the thing is that we have something called. We have two endpoints, or one of them is api, experimental, home, slash workload and in the one is very similar, and it's actually.

A

It's actually started, you just defend it with trades and you get these lists what these lists are and how they are getting used in. You know scenario, so we have these two endpoints uh one is actually one is one list down all of the workload definitions that we have and another one is list down all the three definitions that we have. These are coming right from mystery's registry. So now, if you would see the ui here, we have a directory called mesh uh mystery.

A

So we are reading all the all of the vocal definitions for a certain adapter and we are uh reading all the three definitions for an inductor. So basically, what we just do is we send a get request to this endpoint, which I just showed in here uh this end point and we send a gate request to this endpoint. That is, we load all of the trades and we filter. So if you would see that uh in this workload, the under metadata, we have something called after dot mystery dot io.

A

This is basically the it's it's the way the adapter conveys that hey. This is our capability, I'm registering, and uh my name is sister by the way. The mesh that I actually handle is this steel. So this is how it actually conveys our information. So that's exactly what we are leveraging in here.

A

We are looking if there is metadata if there, if the, if the vocal that we got if there is a field metadata, and if that, if in that field there is this particular attribute and if that matches to adapter, please please keep it filter that thing up. So this is the way. Basically, we um extract these information why these information are required. Basically what we actually need in here. We need certain other attributes also, but the primary thing that is required that is uh used to render this these forms.

A

These dynamic forms is the json schema. So the library that we use is that we are using at least right now is this one, but this comes from rjsf steam. So this is the library one we are using. What this library does is, as you can see in this, uh this basically takes in the json schema the exact same thing that we have in him. It takes in the json schema and it renders a form. So that's exactly what it what is happening.

A

We queried the end points to get workload, diff all of the workflow differentials and their json schema, and we tried to render the form in there, so the form is rendered the, but there are few more um requirements that we have so workloads and trades are two different entities, but traits are applicable on workloads, so each trade actually specifies that hey. I am actually applicable on this workload. So let me quickly.

A

A

A

So uh what I'm showing in here is uh ohm definition, home trade definition, as you can see the trigger kind of stream definition. It also says that hey I'm up able to this this this and this workload. In this case. It's just one thing and it's it's distinguished, so it's saying that hey, I'm after people uh to type uh uh istio mesh um um workload and what that is.

A

Okay, let's see here so the thing that I showed there is uh probably present here also, so you can see that we have the same home definition that we had there. We have the same thing. It says that hey, I'm actually able to uh istio mesh workload and the istio mesh workload is under the workload endpoint. You can see it somewhere here.

A

This is the one. So this is the workload definition. As you can see, the kind is motor definition, so this straight is saying that here I'm applicable to that, and that is how we, that is something that we need to consider in the ui. That is a so there is already a function that takes care of that. That is it to create the workflow trade sets. So that's what we are doing, we get the workload we get the trades and we create the sets.

A

That is, we uh basically pack the workloads in the relevant trades into one section, and then we just uh extract the decent schema uh completely irrelevant and we just parts yeah.

B

A

Absolutely interrupt.

B

Them it's um but ford I think drew has been so I want to catch up. I want to catch up on everybody else, on the call to make sure that uh if they have just the right high level context which which um ukra you gave is good um I'll say it I'll, try to say it differently to make sure uh that that people, I'm gonna, I'm also going to share a diagram briefly. It's not.

B

It would be helpful if this was simpler, but um the detail does explain a few things, so um so tunisian dhruv- and I think I use I think, you've been digesting this as well as dhruv. But but when you go into mesherie's user interface today, which I don't know that I've got running, but if you imagine the management page where the user can select, it's amazing, we don't have a screenshot.

B

The user can select um an operation like what they want to do to the service mesh provision it delete it turn on mtls, um create a provision grafana or prometheus, or they want to manage the service mesh and configure it deploy it all that stuff.

B

um Let me see if we can find a screenshot.

C

Open image right click on the image and open image into a new tab. Nice.

B

So um boy this isn't this is an old one, but it does show off well. This is it's a good consideration actually for our use, because we've been talking about this, and that is that in the left-hand side, um the left-hand menu today is a little bit busy. This is an older snapshot from like v 2. v, 0 2.0. I think time frame we had one two, three four five adapters and you can. A user can load up multiple of the same type of adapter.

B

If you want to run five console adapters, you can and and they'll you can actually do it today and the ui today will automatically show you um sub menu items. If you're running multiple of the same type, if you're only running one of a given type, then you only see one entry.

B

That's a side note the the the primary point to what um utkarsh is explaining is the fact that the uis here are fairly um well they're, really limited and they're static in nature, which.

C

B

The best way of describing their dynamically, the ui, reaches out to the adapter retrieves all of the adapter's capabilities and presents them to the user. Here they are not very configurable at all. Every single service mesh is quite complex and is highly configurable. We're not as we look to expose all of that level of detail, all the fine level of detail to the user to have them configure a service mesh in any any way that they want to.

B

It is not only um a daunting task initially, but it is a sustainability nightmare to have to sustain 10 service mesh adapters that go into a very granular level of depth about how to configure these service meshes rather than writing all that out statically. What word?

B

What happens in the system today is that a service mesh adapter when it connects to mesherie tells mesri all of the things that it's capable of and now and shortly all of them will be telling mesheri in very high level. Detail like that. It is capable of so many operations and for each of those operations.

B

um There's so many attributes that you can tune and tweak and change and there's there's a litany of there's a lot of them and what we're looking at doing is trying to be intelligent and um not and having the ui be dynamic, based on what those registered capabilities, those registered operations that the adapter registers with meshri server, what they say that they're, capable of is just a set of json, there's a bunch of json in there that that describes the operations and how they can be configured.

B

When the ui comes up, it can read from that capabilities registry. You can read from that message. Server database, which is what's being described here, that an adapter wakes up. It registers all of its capabilities, all of its all, of its capabilities with mastery server, and it just stores them in this registry. The ui when it wants to let the user configure all that just reads from the registry.

B

It does that get request that the json that you carsh is showing and instead of having a hardcoded ui that defines exactly what should be shown on a per adapter basis.

B

um It's going to go through the process that would carcer is sharing on it and it'll be highly dynamic, the the inputs, the components, the react components that are shown, the input fields, the types of fields, whether it's a radio button or what, like that's all going to be defined in the json, and that and this process that crash is going through, is the process of interpreting the json, identifying the appropriate react component and input type.

B

That's reflective of the definition of the capability show then show that to the you, you know he's going to show you this new framework, because it's this type of a framework that will be that will that will make us managing 10 adapters.

A

Manageable yeah, so this is the ui that we have right now, and this is completely generated dynamically, so every form that is being shown here instead of hard-coding it right like we have right now. These were generated from json schemas that were presented by the adapters when they registered their capabilities and they are very dynamic. I mean everything that is schema that comes in here.

A

So, for example, you go to trades, uh you can specify, so you can uh list that you want a policy like mutual in the namespaces that you want to specify, and um basically everything that comes in here comes from jesus schema, so uh a doctor can't even change every entire form, just by changing the dc schema and nothing has to change in the e1 and the internals of it is basically this. That is the query. The endpoints we had struck. The integration schema that we might be interested in. We create the sets.

A

The trading set part is quite important because we have to make sure that we display the trades that are applicable to certain workloads. Only so some, for example, mtl, is an automatic site. Conjecture. These streets are available only to the seo mesh workload and not to the virtual service workload. Question service for now does not have any trades, probably people we may not have any trace virtual service, because it's a core concept of still not something that we created uh so yeah.

A

uh The basic idea is that we get all of these things, and now we have components like uh patent service form. What this pattern service form basically does is the ugly the kind of ugly ui that you see in here, as we have these tabs and those kind of things. Definitely these needs to change. This is that I was kind of experimenting to see that what fits in uh well.

A

So this is the place where we actually consume the trades that we retreats in workload, definitions that we get and we render a component uh ask for the json schema. So this is a competent name, part and service, and this is a confident this is actually the place where we will actually customize the ui tweak the u1.

A

So here this function is quite small. All what we see is, if the type of uh if the type of the component is uh rsjsf, that is real, json schema form, uh couldn't come up with a better name but yeah. If the type is rjsf, then what all? What we do is we just?

A

We just take the form element, the form component, that we got from our jsp schema form, and we just render it using the distance schema that we call- and these essence schema- is just these things we just passed along and if the type is switched, the switch is actually I just created, because there are certain workloads which are not very configurable at least right now, so there is uh this um add-on uh there is this workload called, uh for example: jaeger is there on this? One here is the add-on.

A

This is not configurable right now, so you would see it's jason schema. uh Its properties is empty uh right now we do not accept any customization to it. Probably we will, in that case uh it won't be a switch so the right now. The idea is that hey, if json schema is empty, then, instead of rendering the empty form just render a switch.

A

So that we can understand that case uh on operation of operation, because that's all what we have right now so this is uh this: is it right now that is um if the component type is switch.

A

All what you do is uh we render a switch, uh an appropriate title uh and if the type is rjsf, we just pass it pass adjacent schema to the form so that it can take care of rendering all of this thing so had it been virtual service in the entire form that was rendered by this particular company, the other tweaks that we do in the ui. That is how these things get arranged and those kind of things they are actually coming from parent service form. uh Basically, this coding accomplished.

A

I hope uh that thing made sense, yep, okay,.

A

So if you have any questions, please to ask, because we have some time.

C

So basically, what is going on here is it presently? What in this card is this screen is doing uh presenting all the json that we have got from the adapter.

A

Yeah, uh actually, these uh yeah, you are uh right, um these schemas, they were from adapter, but they could be from. uh But uh when these, whether you are actually queried, it queried the registry that lee actually showed in the presentation. So measuring has a mission. Server has a registry where it keeps track of all of the capabilities, these. uh uh Basically these workload, definitions and these trade definitions. They actually came from the capabilities which indirectly came from the raptor.

C

A

Okay, any other questions that someone has.

D

How does the each adapter generates its own schema.

A

Yeah, actually, these are um these are generated. um They are not quite generated, they are quite written. uh We write them. So if you would.

A

See no, this is true, so.

A

uh If you would see we, this is the definition list, um so this is ohm definition and then this is over schema. The other is actually the metadata like hey where the raptor is. If mr wants to reach out to this particular thing where to reach out to- and this is the metadata- that's not specific to the patterns operation- it's just specific to the ui. So if you so, this is the workload definition and the json schema is this. These things are written uh manually for most of the operation for virtual servers.

A

This was this is quite heat, as you can see. No, I didn't write this uh manually. I generated it using the using uh the open api spec that is theo has basically what I did was still using ctl. I automated I was getting the manifest and then generated it to jason's scheme on the fly, so this thing was generated on the fly uh by on the fly. Basically, you mean that I generated automatically and paste it called by pc written here and yeah.

A

So it's kind of like um offloading the responsibility of so instead of doing all this stuff manually in the ui. What we do is we kind of just write json, which indirectly gets converted into the ui. Maybe it may look like that. You're offloading responsibility to the adapters, but it's more like.

D

A

Like minimizing, I want to.

D

Add a add-on, let's say I want to add a.

A

Yeah so uh yeah in in the case of uh on two jason would be arden. Now one would be kyani underscore definition json and there would be uh it's json schema, but that's that would be mostly it, except that you also have to make sure that that gets registered. So that would be all that would be needed as soon as you do it in the raptor. As soon as you are the functionality of the adapter it's available in the ui. Also, it would be available under there.

D

A

Okay, so that's the dynamic ui and I think we actually explained the entire flow that how these things happen.

A

It doesn't even have any other question.

D

Are we planning to have certain features depending on the users who are logging and if we are in that case, adapters are open source? Aren't they.

A

uh So no well, that's not uh so as far as I have, um but not this one as far as I have uh quote in here, they do not at least for now. uh There is no uh consideration for letting something display on only under certain circumstances.

A

So, okay, yeah.

D

I think close source adapters.

C

Because I can't see something like that.

A

uh Oh, what exactly do you mean by hosted up, I mean deployed, I mean deployed.

A

uh No, so we um so you can, let's see what service mesh is currently running a system, but we do not actually track what at least uh right now. We do not trap in this ui that what all the workloads are in the mesh, but we do. uh We will uh probably have that in mesh map, where it will be able to capture that all of these things after makeup application. These are the applications that are present in the mesh, probably in the.

A

Visualizer, so actually uh the contribution by lens is pretty uh small. I guess that is all the ui tweaks needs to be done here. That is, you can add the custom components here and if you want to modify the entire form, this is the computer that you will actually changes to. As I was so yeah, that's pretty much. It.

B

So let me let me see if I can recap this, which is that there's there are three files mesh under this meschery mesh interface folder. um What's the index.js things is an example. It's the example that you're showing now.

A

Yeah basically electron is, is the file which has a responsibility of collecting all of the information then passing along. So basically, uh index.js is a smart company. If you talk in the react terms, it's a smart company, it does the logical things that it creates appears, and it queries the end points and basically it sets everything up, and then it just calls these. uh This is not my term. It's a reactive, it called the derm components uh which do not have any responsibility other than rendering uh the ui.

A

So index.js basically did the querying part creating the sitting, the sets part, and then it just called the pattern service form it took the balance of this form and patent service form basically uh rendered the this particular ui and the internals of it gets rendered by by parent service. It also doesn't care that where all of these things came from, all it cares about is that it it was given some json schema and has to render it, and uh it just does that basically renders the internals of the form.

A

Basically, these parts.

B

Nice, so as we look to, did you say dumb component by the way, yeah.

A

uh That's actually what we.

B

Use sure yeah um all right so then, as we look to propagate the use of uh rjsf propagate the use of the capabilities registry, essentially the other way of referring to like what we're trying to do here is to um yeah. You know embed the use of the capabilities registry, um so we're transitioning from today's model, which is when you pull up the manage and the management ui is the first focus.

B

We're gonna, see the um this method um find its way into well, we will see it find its way into other uis, but suffice to say for now, like management ui is the core focus of where this will manifest itself, and so, as the as contributors um enhance each individual mesh readapter with the ability to register their capabilities in this way, um then over time each individual like. Actually, I guess I should ask this crush- is the concept here? Is that.

B

Today, there's a singular management page and to ayushi's suggestions and sort of questions that, maybe maybe we need multiple routes like maybe the route that's there today could can be changed and actually, I think, you're showing that management hto. So that's that's great, and um that doesn't mean that we don't want a like if you just were to visit slash management. Well, that would take you to the old page, but the old page is we.

B

We do want a slash management like we do want an overarching management page that ends up showing a bunch of other. It's it's a different design than it is now uh anyway. My point to my question was.

B

Other than so so, the contrib okay, so the the point by which this effort is is that proof of concept is done. We've got a the beginnings of what would be a new management page, the beginnings of how that the we can now break down into different routes, each individual service mesh type that each of the pages are conceptually.

B

Just the same like that, are we looking at publishing the same? Are we going to have actual individual?

B

We would have um small stubs for individual pages, but the vast majority of the.

A

Actually, right now it's completely random, so we have something called square break brigades and histories. uh So basically the route that you see here- slash management, starship, steel. So now the mesh name is this theo. We I just craft that thing, uh basically the end portion of it whatever it is, uh and uh I just feed that so there is only one page and that one page gets changed uh based on the route.

A

If it's istio uh I'll craft, this, you think I'll pass it on to this index.js file and that will be treated as our doctor name, this rapper and based on that, we will actually query the week. Query the registry and filter out the right things. So the forms will change based on the route and uh there is in code terms. There is only one page and that's this page.

B

Cool so of what needs to be done, is I mean there's some css stuff sure, but um the more meaty work is to work through some of the rest of the input types like the the trait properties, the to make sure that if and we should go through and itemize what we think that those are like hey.

B

um Some of these are switches that that you've done you demonstrated some of these are uh input. You know drop-down lists. Some of these are you know, text fields. Some of these are but yeah, so so the let's, let's see if we can, while I think that the other recording that you have that we just did will be referenced time and time again. I don't know that this one, my hope is, is that this one won't be is that this is more.

B

This is kind of the point of this, which is like it's it's by and large, a one-time effort that um sets the ui on such a dynamic such a path. That's so dynamic that um for the management section, it's like it's self-sustaining, it's like! Well, you know, I just you know I'm presenting what I'm given and I'm presenting it in the way you know in a curated way, but so right now for add-ons.

B

You have logic in here that that identifies that, if you're a trait of a certain type, then I'm going to compartmental I'm going to categorize you and group you into a grid. You know of cards over here and and then because, because you are of type add-on right now I mean there are no property. Is it really the fact that there are no properties for the type add-on that you're deciding to show a switch.

A

So uh the logic is that so um the add-ons category has nothing to do with do with the switch. It's just that, uh while rendering it figured out that this particular component does not have anything in the json schema. uh So uh had I given this to rjsf, it would have just rendered empty form with the summit button, so it just looked into that that uh there was nothing so just render a switch.

A

Had this add-on have something in the properties that had this been configurable, then in that case it would have rendered a proper form in there. Instead of so, basically add-ons has nothing to do with the switch it's just that jason's scheme was empty, so it rendered a switch.

B

So um how can how can these gentlemen, that makes total sense and yeah? I I get what you.

B

How can how can they, how can you hand off the baton not entirely, but how can you split up the baton and hand it off some? What should these guys be? How can they help.

A

So uh first thing is that I've been trying to first thing. Is I've been trying to figure out that how to appropriately show uh settings and trades for a port global? So let me show a button file so that it makes no sense what I'm trying to say. So, if you would see uh this is a workflow.

A

This is a service of type uh istio. Mesh here is something called settings and there is something called traits uh settings. I am setting version 1.8.2. You can see the same thing being reflected here. I am. uh There is also in this section called trades, and there are three trades that are being applied this one. This won't appear here, because this is a restricted trade. uh There are two categories of trade we can't become that later, but uh these are two trees, mtls and automatic cycle injection.

A

uh You can see this here. Some trades are applicable to every workload. Some trades are applicable to only certain workloads that will be handled by indexologists. I don't think that this thing would be would have to be tweaked, at least for now uh so yeah. uh The thing is that uh every workload has some treats as well as settings, and we need to show that uh in a way that it does look like that, hey uh so right now, if you would see it's, it's not very, uh very good.

A

As we are saying you're showing issue mesh under settings settings of what no one knows and then we switch to trades and it comes to automatic cycle injection and mpls, and we from pattern file. We know that hey, it's uh traits are actually part of the workload, uh but from here it's not quite clear, I mean settings is completely different. Rates is completely different than estimations being shown here. Probably assume it should be moved up and name should be changed, so uh the ui should be able to express that thing.

A

I don't think that anyone wouldn't if anyone uh hasn't seen a pattern pipe. I don't think they would be able to figure out for now from this ui that all of these things are actually a part of same workload, because it just does not convince that. So that's one thing that I cannot think of how to present it better. But, probably are you sure drew would be able to talk more on that.

A

The second thing is that uh rjsf, as a library uh needs a lot of tweaking not a lot of, but uh definitely a bit. Some things are not very uh not exactly fitting into the ui that we have so some of the some of the text, components that we have in here they can be. They can leverage the smarter components that so uh for namespaces. You would have seen things yeah. This is a namespace scene. This is a input box, that's fine, but we have smarter, smarter in namespace components.

A

I'm not sure, if would be like leveraging that I'm not sure how how restrictive they will make the dynamic ui, but that's something to be considered. I guess uh which I haven't here, that is, we can use those smarter confidence which actually detect that here all of these names are available and they will present it to you it to you in the drop uh basically in him. So right now it listed down default news is because it figured out that hey burning, so it's called default.

A

So if you presented it here, probably that can't be also shown here. So these are a few things which may need some working on, which I haven't yet worked. But there is one thing that is converting all of the inputs into a pattern file. That's something probably I'll be doing so yeah. These are three kind of tasks, one of them. One of it is something I'd be doing. I'd be winding up. Some other is that I'm not very good at uh which either of you uh in the meeting are in decision.

A

uh So that's something that others can probably.

C

So we are actually converting the previous management page to this page.

C

Or it's just to represent right now, because there are too many things. Do we need to show each and everything right now that we are getting from in the format of jason.

B

It's the latter, it was it's um kash, doing a prototype and and pulling pulling things together and uh not and trying to bother himself with some amount of um like basically going through and prototyping, where it is that he can swap out. uh You know what let me not describe it and just answer your question: it's not the final design. It is like even without me, having said it, um it's exactly. We should be displacing the management page. That's there today, with this.

B

All of the pages should go like be converted to this style of dynamic interpretation. The user ex. The the way that the screen is laid out is um not something that utkarsh was really trying to focus on and think through and get right. He was trying to get the framework um set forth, and so we need to do some designs on this. uh Some of it is.

B

Like really close to what I envisioned would be there already, which is like those add-ons there isn't anything else to do with them other than turn them on and off, and so in our office on or off switch makes a lot of sense.

B

It might be that hey, we should put the little gr the logo for grafana and prometheus, and we should you know, curate the string and just have the name of the thing not istio add-on or, like you know, all that that stuff, none of that is in um you know, in a design yet, but all of what I just al most of what I just said is somewhat obvious is like hey, it shouldn't, say: istio add-on, it should just say rafana or jager.

B

Those are things that can be acted on to like now ayush um without a design. We do need to go through and really and give some deep thought as to what the design looks like.

A

uh So well, just one thing that is: these memes are also being controlled by the json schema, so actually the jesus needs to change a bit as uh yeah, so the name actually comes from this, so I kind of not did the good job of naming uh things I just named it, which made sense to me. So the title that we saw uh here and here automatic cycle injection should be properly spaced and properly calculated. That actually came from here.

A

So all we have to do is to change this name, and that will be reflected that will be reflected in the ui um and it will not have any consequence on any flow. It's just a display thing.

A

And so it's true for this, these things actually.

B

Okay, let's talk through a little bit more, let's make sure, let's talk through more of that, so like for namespaces.

B

um This is well or okay, so for sidecar injection, this is like what all namespaces would you want to label with sidecar injections, so you can enter in. So um I use you'd worked on this. The current form of this, which is there, will what one of the things we need to intertwine is that yes, there's an operation that will perform this. You know that that's new in the art, our jsf style. We also need to intertwine the fact that there's mesh sync data that probably already says well, there's a namespace called default.

B

There's a namespace there's like these five namespaces already there you can enter in your own or you can tag you can pick any of the existing as well, and so that's something to.

B

It's just it's just it's just is uh what is it called a react, um data binding or.

A

We have these components, the text field, confidence and they are not very smart. I mean- can enter anything, but we have a smarter namespace component, smarter input, confidence, so others are showing earlier. That is this names, uh this input component. As soon as I clicked on it. It uh showed me this drop-down default uh because it mesh sync actually set this information to machine by that hey this name space and these namespaces.

C

Are available? Actually, I think not. It's still not working. If you make uh something with the other name and try just um try the namespace again, then also it will just show default only. I think.

A

C

Now clean this.

A

So if I, if I want just.

C

Toss it see, it will just show default only it's actually not getting all of it. It's just showing default its program, programmatic,.

A

It says yeah, no, actually the thing is that probably in your case for for example, in my case, uh mesh thing is not running uh or probably in your case, uh uh kate's cluster was not running or meshing was not connected, but I think, uh but the component's actual functionality is that it will list down all of the available um available name spaces.

A

Okay, okay, so I think uh we were saying that uh that com that component can be used in here instead of a dom text component, which just takes an input. This is achievable, uh I'm not sure what all limitations it's going to put in, but this is an.

C

A

There is advanced customization and this it actually takes in. uh You can actually provide in custom components for custom things, I'm not sure what all restrictions it will offer or what all things that we may lose. We may lose some validation or something like that. I'm not sure about that, but um definitely uh the library uh as as it is, it actually offers those kind of customization. So one of the things that we can switch, we can work on. It is actually changing this input field to be a bit smarter.

A

That is providing the custom con component that we already have.

D

A download here, like you just said in the schema there are options to I make it go smarter. That's what you said.

A

In the schema there, uh I couldn't.

D

Like, uh let's take this use case, and this let's say we want the names which are always there to be there. So we need to add those in schema, because if we do, then the adapter will give it the name that might make it messy.

A

No, so um actually the uh I'm not sure if I exactly get the question, but if, if it is like uh so adapter only registers its um capabilities when it boots up, it won't to be able to fill in these information later on uh it actually can it can fill these information and register all of these things again, but I'm not sure if we'd be doing a.

A

D

That make sense yeah, because that's what you would have to do from adapters, but then I'm thinking like how is it abstracting, I'm not confused in that sense like there is a thin line right, the more you customize it, the less abstract it will be like customized.

A

D

A

So what we can do is uh when, uh when we detect a field called news but yeah, definitely uh it's kind of sitting in stone that hey uh the field has to be called namespaces and jesus schema, and if it is called namespaces, then we can actually render this field. But as soon as someone validates that, uh although the pattern file would work just fine, then that would work just fine. We won't have that smarter confidence. Is that what.

D

That's that's what we have to do anyways like why. Why was this.

C

D

Like true, I was just thinking that all different kinds, more like that won't be.

A

D

Like the more smarter components you will have the less abstraction. That's what I was thinking about.

A

A

So the more custom, the things are, the more specific they are to them.

C

That's what I was trying to ask when I asked that if we are going to display everything like this like we are using that library, it will show it according to itself and whatever is coming as a json.

A

uh So that library, actually uh library takes in chunks of json schema, so, for example, this particular thing is the entire form. So uh it's a session like that, can we hide the internals also, uh for example, virtual service? Probably a good example. Service is just the entire thing. This is just one json schema form, so is the idea that uh they can be high hide? Can we just show it? Can we just show probably hosts and http and tcp is lesser use, then export? Who is this?

A

Indeed, it is not listings, but can we hide that thing, but we won't be able to, because rjsf is handling that for us.

C

Is that the question yes, like that, okay, yeah.

A

Actually, I'm not sure if that customization is offered by the library or what all fields should be, and I'm not sure if we sh, we would be doing that early can't answer to that, because if we go on and do hardcore stuff that they hide this and do that then it's kind of like that. Ui is now aware of all of the things that are coming to it. What could be government.

B

Yeah we're gonna. We will need to strike a balance. There will be certain areas that that might have to be customized per mesh, maybe there for some of the areas that we might customize.

B

It's likely that that same custom customization is applicable to other um service meshes. So this is. This is a good example right here, so so this the experience that we would ideally have when someone is creating a virtual service.

B

Well, um it ends up the the.

B

The ui that people are most familiar with for configuring, this type of a thing is a lot of times set up as a statement going acro going in a horizontal left to right mode. It's like it has to deal with how people think of network traffic generally.

B

This is sort of the way that uis have represented. This is that generally you're sort of starting from the left-hand side of your ui and you're flowing across the screen, like your traffic, is so the source of the traffic is in the left-hand side, the destinations on the right-hand side and what you're doing is applying filters.

B

You're you're, defining firewall rules, it's like, if you guys want to get a sense of what this would ideally look like, and maybe we can do it better, but the way that things have been historically presented to people is um well is not so not so great. um Let me share with you what that might look like so I'll, just type in configuring firewall rules.

B

Let's see if there's an image.

B

um Okay, here's uh some wow! This is really hard to read. um If you can read this it, it sort of goes like this. There there are just like there's a collection of rules that are individually defined, that that, when you bring them together, um each rule a pack, a piece of traffic that wants to go across the service mesh or across the network. It needs to be evaluated against each individual rule. So there are three of them here and usually saying: okay they're.

B

In order they will be evaluated in order one two, three: four: five: six: okay where's the traffic coming from that's the source: where is it going to that's the that's the destination like and there's different ways that they they identify these, but anyway, then just various considerations to take account on those. So when you um utkarsh, if you share again um the.

C

B

Service, this type of a like each of the service meshes you can tell them in a granular way. What you want to have happen to traffic, to request that that's the large part of the focus, what a service mesh is, and so we're going to have a lot of these types of input, forms that are saying.

B

Okay, you have a request. A network request, an http request coming from a client, it's going to hit one of these microservices.

B

You know that there's some attributes about this request and some attributes about the service that we want to apply this routing rule over. So, if you go back up to, if you go back up a bit to like the top of virtual service, so yeah so okay, so the first part just says: there's a specification: okay, fine! um um There is a list of name. The second thing export to is like okay. Well, namespaces is our queue here, for um when we define this route, this virtual service, when we define this network rule, we have.

B

We basically have this. This policy now we'll have this. This virtual service, this this policy it'll, contain all these attributes all right for so for the export too, it's like well, this is going to define where the policy is applied. In what name spaces should this policy be applied? Okay, fine! That's a that's! The same namespace style thing that we've been looking at right: it's just a drop down a collection of lists of names, okay, fine um part of the policy- and I won't explain the technicals behind the rest of these things.

B

But what I'm trying to tell you guys is like it's like. Okay, um when the traffic comes into the mesh, it's going to go through a gateway. There are many gateways which gateway. Does this virtual service apply to? So it's just another attribute and like in this. What we, what we would prob like, if you have a not like the worst experience that, like a middle of the road experience that you would deliver here, is okay. Well, there's a list of existing gateways, there's four of them all right!

B

So then, just provide a drop-down list that people choose to associate this new rule, this new policy they're going to associate it to maybe it's a multi-select. Maybe it's just a single thing um and that needs to be defined as part of the definition of the pattern like is this? Does it accept just one thing: is it required? Does it accept just one thing or does it accept multiple, and so that would define what type of component that we expose in the ui?

B

um For now, what we want to do to collab together is we want to iterate iteratively step toward from horrifically ugly super generic, very dynamic, uis, marching forward with each um with each segment of the pattern file. So a virtual service, it's kind of a big thing, there's a lot of things to a lot of properties that it has. We need to walk from from this, which is I'm so excited about just this from super ugly, um highly powerful, very dynamic.

B

I can hardly understand what this thing is saying: style, ui to just um refining refining and eventually on some of these we're going to find this inflection point, which is what drew is pointing out which is like if we don't just write some custom code to consider for istio. Specifically, it's just not going to work. People aren't going to understand it. Okay, well as and when we get to those we'll identify those. But this virtual service is a great example of like well.

C

B

Complex there's a lot of inputs to capture here, but it's act, and so we want to have a curated experience, something that you know people can understand as they navigate this it that that's a very similar experience as to what people need to do in each and every mesh. So it's not like. Even if we get highly custom, um it is hopefully the case that we can reuse that across different surfaces,.

B

So there's uh you know it's interesting. I I think this is at first. I thought this was easier. Now this might be harder than the other session. I don't know we do. What we want to do is end the call shortly before we do. We want to identify small things that people can work toward.

B

So let me start by asking so I know tunuge is here because he's keeping pace and um providing input and being a maintainer that he is and being a mesh methodist, but he's not here to take on new work because he's um all all full elsewhere he's gonna come back, though, and that's why he's here to absorb this as we go and provide opinion and etc and then, but for the the rest of us.

B

uh With a slight hesitant to see towards dhruv, who also has a full plate of a full internship, that's lined up for him that he's working on um for the rest of us. We need and drew may take away some action items from this. Maybe, but let me ask um ayush and chinmay.

B

If you have already taken away a couple of things that you know you're going to go work on on this.

B

So chin, may I say that with hesitancy toward you, because you're already busy in some other places in the community, because um this hasn't been a focus for you as of late and so no pressure chinme but ayush feel the pressure.

B

And if the answer is like well, I'm not quite sure just yet I'm still digesting that's totally fine. I just wanted to we'll break that down right now. I just wanted to ask if you already had ideas.

C

I think it's difficult for me like I am. I have different other works. Also, I'm having an internship right now.

B

C

Like I would like to work, but no commitments that I will be doing.

B

Yep yep, so I use um as we talk about the you know. We've talked about like redesigning the management ui. That's this or like. Rather the framework upon which that would be done. Is this um so there's it would? It would be good if we got you touching this some like if there was, um and maybe that's not right now- maybe that's a little bit later.

B

Irrespective uh crush in your mind, what what are the next steps on this, you said three.

A

Earlier yep, uh so one of the things basically presenting the in in a better way, because it's not conveying what's supposed to uh at least right now. um Second thing is that there are a couple of issues. This uh uh another issue is that summit button is being displayed everywhere. It should not, because these things are not individually, I mean they are individually right operations also, but uh ideally they are supposed to be applied, I'm not sure so automatic side conjection. That is that's an operation itself. You can't do that um in spite of.

A

Basically, you may want to not provision it. You may already have a service mission. Still you want to add or remove some automatic site conjugation, so you uh may invoke these operation individually, so in that case you may need submit form. It is that the ui is right now not very is not in a good position. It does not convey all of the things that can do it. It shows a lot, but still not enough.

A

The thing is uh it: it's not showing that how to delete a names or automatic site transaction I mean if, for example, there is a namespace called test and it already has a label, and if you want to remove it, it doesn't shows that, although that's possible delete operation is a possible operation, but we do not show that here there is only provisional provision provision, no uh deployment deposition. So we need to accommodate that also in the world, although the ui is completely full the second.

A

The third thing is um the one that I'd be doing, that is taking all of these inputs and creating a valid pattern file so that it can be applied on.

A

B

Good, I think we accomplished the mission of the call which um which this might be at a point by which uh and based on other people's schedules, that um food crush you might be carrying most of it forward. For the moment until a couple of items are a couple of you know, until we've taken a couple more steps, and until some people have lighter workloads, there's one item in there that it's the data binding part to of mesh sync data.

B

Is that remedial? Or do you think that that's going to be involved.

A

um Actually, I haven't have to see that how, although I did some of the implementation, I do not exactly remember how they were exactly communicating, so I will actually have to look at how those things were coming in sync. uh I did that in issue. I do not remember how the interns of it- I remember the subscription was there, but how do these were interrupting? That's something to look into.

B

B

And so one individual um gotham we'll have to make sure he gets this recording, so he can actually he comes to mind as one of those individuals that's been focused on those subscriptions as well.

B

Well, nice! Well, um anybody have any other questions. I think I think it's been a successful session successful in that there was a lot to introduce and even though no one may be taking on any specific actions at the moment, each of you ayush in particular, you'll, be really well positioned to take on a couple of these items in the future.

C

I'll be doing things but little by little.

C

Still not too much here. I've not gone through like this.

B

Yeah, that makes sense, um if you you know, I don't know if it makes it harder to see to see all the surface mesh specific words in here or if it makes it easier like it's easier because there's an example of what's going on or if it's harder, because it's a bunch of gobbledygook anyway, thank you so, but yeah good um crush. This has been. It's been good. This is really helpful. I'm I mean like this. This changes, the game.

B

B

B

Think about that.

B

All right, anybody have any other questions for us.

B

Nice, it's a lot yeah good anyway, we'll get the recording posted um ooh crush. I like one area that, like is slightly, gives me some makes my spider senses makes them at the back of my neck. uh Tingle is uh well how it's good and bad, and I don't know if I should. I don't want to cast it in it with a negative connotation, but I wonder if the direct linkage between the pattern file yaml in terms of the title.

B

um Well, it's quite convenient and powerful. You could see without a lot of intermediary markup that it's possible.

B

Those traits could get verbose and actually well so long as it's the trait like the definition of the thing and not the pattern file itself, which is a user-facing you know set of ammo, then we're then I think you know we're okay and a lot of this, like that's being shown here, that description of the spec that the text down below that's that's coming from the trait definition, not from the pattern file for the workload definition. So so that's good got it.

B

Okay, this does it for me thanks a bunch of cars.

C

A

A

B

I think that's it going once going twice.

B

Okay, cool. Thank you.